# -*- coding:UTF-8 -*-

# region 导入依赖项
from enum import Enum as _Enum
from math import sin as _sin
from math import asin as _asin
from math import cos as _cos
from math import radians as _radians
from math import fabs as _fabs
from math import sqrt as _sqrt
from math import pi as _pi
from math import tan as _tan
from math import atan as _atan
from math import atan2 as _atan2
from math import log as _log
from math import exp as _exp

from DebugInfo.DebugInfo import 打印模板 as _打印模板
from DebugInfo.DebugInfo import 黄字 as _黄字
from DebugInfo.DebugInfo import 青字 as _青字

# endregion

# region GPS坐标换算方法
_axis: float = 6378245.0
_offset: float = 0.00669342162296594323
_x_pi: float = _pi * 3000.0 / 180.0
_earthR: int = 6378137  # 6371393
_赤道周长: float = 2 * _pi * _earthR


def _gcj2BD09(经度: float = 0, 纬度: float = 0) -> tuple[float, float]:
    z = _sqrt(经度 * 经度 + 纬度 * 纬度) + 0.00002 * _sin(纬度 * _x_pi)
    theta = _atan(纬度 / 经度) + 0.000003 * _cos(经度 * _x_pi)

    # 经度, 纬度
    return z * _cos(theta) + 0.0065, z * _sin(theta) + 0.006


def _bd092GCJ(经度: float = 0, 纬度: float = 0) -> tuple[float, float]:
    # return 经度, 纬度
    经度偏置 = 经度 - 0.0065
    纬度偏置 = 纬度 - 0.006

    z = _sqrt(经度偏置 * 经度偏置 + 纬度偏置 * 纬度偏置) - 0.00002 * _sin(纬度偏置 * _x_pi)
    theta = _atan(纬度偏置 / 经度偏置) - 0.000003 * _cos(经度偏置 * _x_pi)

    return z * _cos(theta), z * _sin(theta)


def _bd092WGS(经度: float = 0, 纬度: float = 0) -> tuple[float, float]:
    # return 经度, 纬度
    参考经度, 参考纬度 = _bd092GCJ(经度, 纬度)

    return _gcj2WGS(参考经度, 参考纬度)


def _wgs2BD09(经度: float = 0, 纬度: float = 0) -> tuple[float, float]:
    参考经度, 参考纬度 = _wgs2GCJ(经度, 纬度)
    return _gcj2BD09(参考经度, 参考纬度)


def _wgs2GCJ(经度: float = 0, 纬度: float = 0) -> tuple[float, float]:
    if _outOfChina(经度, 纬度):
        return 经度, 纬度
    else:
        经度偏差, 纬度偏差 = _delta(经度, 纬度)
        return 经度 + 经度偏差, 纬度 + 纬度偏差


def _gcj2WGS(经度: float = 0, 纬度: float = 0) -> tuple[float, float]:
    if _outOfChina(经度, 纬度):
        return 经度, 纬度
    else:
        经度偏差, 纬度偏差 = _delta(经度, 纬度)
        return 经度 - 经度偏差, 纬度 - 纬度偏差


def _gcj2WGSExactly(纬度=0, 经度=0):
    return 经度, 纬度


def _delta(经度: float = 0, 纬度: float = 0):
    纬度偏差 = _transformLat(经度 - 105.0, 纬度 - 35.0)
    经度偏差 = _transformLon(经度 - 105.0, 纬度 - 35.0)

    radLat = 纬度 / 180 * _pi
    magic = _sin(radLat)
    magic = 1 - _offset * magic * magic
    sqrtMagic = _sqrt(magic)

    纬度偏差 = (纬度偏差 * 180.0) / ((_axis * (1 - _offset)) / (magic * sqrtMagic) * _pi)
    经度偏差 = (经度偏差 * 180.0) / (_axis / sqrtMagic * _cos(radLat) * _pi)

    return 经度偏差, 纬度偏差


def _outOfChina(经度: float = 0, 纬度: float = 0):
    if 经度 < 72.004 or 经度 > 137.8347:
        return True
    elif 纬度 < 0.8293 or 纬度 > 55.8271:
        return True
    else:
        return False


def _transformLat(经度: float = 0, 纬度: float = 0):
    ret = -100.0 + 2.0 * 经度 + 3.0 * 纬度 + 0.2 * 纬度 * 纬度 + 0.1 * 经度 * 纬度 + 0.2 * _sqrt(abs(经度))
    ret = ret + (20.0 * _sin(6 * 经度 * _pi) + 20.0 * _sin(2.0 * 经度 * _pi)) * 2.0 / 3.0
    ret = ret + (20.0 * _sin(纬度 * _pi) + 40.0 * _sin(纬度 / 3.0 * _pi)) * 2.0 / 3.0
    ret = ret + (160.0 * _sin(纬度 / 12.0 * _pi) + 320.0 * _sin(纬度 / 30.0 * _pi)) * 2.0 / 3.0
    return ret


def _transformLon(经度: float = 0, 纬度: float = 0):
    ret = 300.0 + 经度 + 2.0 * 纬度 + 0.1 * 经度 * 经度 + 0.1 * 经度 * 纬度 + 0.1 * _sqrt(abs(经度))
    ret = ret + (20.0 * _sin(6 * 经度 * _pi) + 20.0 * _sin(2.0 * 经度 * _pi)) * 2.0 / 3.0
    ret = ret + (20.0 * _sin(经度 * _pi) + 40.0 * _sin(经度 / 3.0 * _pi)) * 2.0 / 3.0
    ret = ret + (150.0 * _sin(经度 / 12.0 * _pi) + 300.0 * _sin(经度 / 30.0 * _pi)) * 2.0 / 3.0
    return ret


# endregion


# region 定义 GPS坐标系类型 枚举
# @_unique
class GPS坐标系类型(_Enum):
    """
    这是一个 Enum， 定义了可使用的GPS坐标系名称
    """
    智能推理坐标 = -1  # 智能推理坐标, 等效于 wgs84坐标
    gcj02 = 0
    高德地图坐标 = 0
    腾讯地图坐标 = 0
    bd09 = 1
    百度地图坐标 = 1
    wgs84 = 2
    谷歌地图坐标 = 2
    GPS接收机坐标 = 2


# endregion


class 墨卡托坐标类:
    """
    墨卡托坐标与GPS坐标的换算算法,参考自: https://blog.csdn.net/qq_28918357/article/details/122939246
    """

    def __init__(self,
                 x: float = None,
                 y: float = None):
        self.x: float = x
        self.y: float = y

    # region 访问器
    @property
    def 有效(self) -> bool:
        if self.x is None or self.y is None:
            return False
        else:
            return True

    @property
    def 无效(self) -> bool:
        return not self.有效

    # endregion

    def 设置坐标(self, 坐标: 'GPS坐标类'):
        """
        将指定的GPS坐标类对象转换为墨卡托坐标值
        """
        self.x = None
        self.y = None
        if 坐标.有效:
            self.x = 坐标.经度 * _赤道周长 / 360
            self.y = _log(_tan((90 + 坐标.纬度) * _pi / 360)) * 0.5 * _赤道周长 / _pi

    def GPS坐标(self, 目标坐标系: GPS坐标系类型 = GPS坐标系类型.智能推理坐标) -> 'GPS坐标类':
        """
        将当前的墨卡托坐标值,转换为指定的GPS坐标系下的 GPS坐标类 对象
        """
        if self.无效:
            return GPS坐标类(经度=0, 纬度=0, 坐标系=目标坐标系)

        return GPS坐标类(经度=self.x * 360 / _赤道周长,
                         纬度=_atan(_exp(self.y * _pi * 2 / _赤道周长)) * 360 / _pi - 90,
                         坐标系=目标坐标系)


class GPS坐标类:
    """
    定义了GPS坐标数据结构，您可以通过 GPS坐标类.帮助文档() 或者 GPS坐标类对象.帮助文档() 来打印相关的帮助信息
    """

    class __GPS坐标子类:
        def __init__(self,
                     经度: float = None,
                     纬度: float = None,
                     坐标系: GPS坐标系类型 = GPS坐标系类型.智能推理坐标
                     ):
            """
            GPS坐标结构类,为了避免循环引用,做个子类
            :param 经度:
            :param 纬度:
            :param 坐标系: GPS坐标系类型
            """
            self.经度 = 经度
            self.纬度 = 纬度
            self.坐标系 = 坐标系

        @property
        def 坐标(self) -> tuple[float, float]:
            return self.经度, self.纬度

        @property
        def 有效(self):
            return self.坐标系 is not None and self.经度 is not None and self.纬度 is not None

    def __init__(self,
                 经度: float = None,
                 纬度: float = None,
                 坐标系: GPS坐标系类型 = GPS坐标系类型.智能推理坐标,
                 纬经度: tuple[float, float] or list[float, float] = None,
                 经纬度: tuple[float, float] or list[float, float] = None):
        """
        GPS坐标类结构
        :param 经度:
        :param 纬度:
        :param 坐标系: GPS坐标系类型
        :param 纬经度: 纬度, 经度 元组 或者 列表
        :param 经纬度: 经度, 纬度 元组 或者 列表
        """
        self.__经度 = float(经度) if type(经度) in [float, int] else None
        self.__纬度 = float(纬度) if type(纬度) in [float, int] else None

        if not 经度 or not 纬度:
            if 纬经度 and len(纬经度) > 1:
                if not (False in [type(值) in [float, int] for 值 in 纬经度[:2]]):
                    self.__纬度 = float(纬经度[0])
                    self.__经度 = float(纬经度[1])
            elif 经纬度 and len(经纬度) > 1:
                if not (False in [type(值) in [float, int] for 值 in 经纬度[:2]]):
                    self.__经度 = float(经纬度[0])
                    self.__纬度 = float(经纬度[1])

        # 智能修正经纬度
        if isinstance(self.__经度, float) and isinstance(self.__纬度, float):
            # 纬度值不可能超出 [-90, 90] 范围, 如果此时间检测到 经度值在 [-90, 90] 范围内, 则自动修正之
            if abs(self.__经度) < 90 < abs(self.__纬度):
                self.__经度, self.__纬度 = self.__纬度, self.__经度

        self.__坐标系 = 坐标系 if isinstance(坐标系, GPS坐标系类型) else GPS坐标系类型.智能推理坐标

        self.__gcj02坐标: GPS坐标类.__GPS坐标子类 = GPS坐标类.__GPS坐标子类(坐标系=GPS坐标系类型.gcj02)
        if self.__坐标系 == GPS坐标系类型.gcj02:
            self.__gcj02坐标.经度 = self.__经度
            self.__gcj02坐标.纬度 = self.__纬度

        self.__wgs84坐标: GPS坐标类.__GPS坐标子类 = GPS坐标类.__GPS坐标子类(坐标系=GPS坐标系类型.wgs84)
        if self.__坐标系 in [GPS坐标系类型.wgs84, GPS坐标系类型.智能推理坐标]:
            self.__wgs84坐标.经度 = self.__经度
            self.__wgs84坐标.纬度 = self.__纬度

        self.__bd09坐标: GPS坐标类.__GPS坐标子类 = GPS坐标类.__GPS坐标子类(坐标系=GPS坐标系类型.bd09)
        if self.__坐标系 == GPS坐标系类型.bd09:
            self.__bd09坐标.经度 = self.__经度
            self.__bd09坐标.纬度 = self.__纬度

        self.__墨卡托坐标: 墨卡托坐标类 = 墨卡托坐标类()

    # region 访问器
    @property
    def 经度(self) -> float:
        return self.__经度

    @经度.setter
    def 经度(self, 经度值: float) -> None:
        self.__init__(经度=经度值, 纬度=self.__纬度, 坐标系=self.__坐标系)

    @property
    def 纬度(self) -> float:
        return self.__纬度

    @纬度.setter
    def 纬度(self, 纬度值: float) -> None:
        self.__init__(经度=self.__经度, 纬度=纬度值, 坐标系=self.__坐标系)

    @property
    def 坐标系(self) -> GPS坐标系类型:
        return self.__坐标系

    @坐标系.setter
    def 坐标系(self, 坐标系: GPS坐标系类型) -> None:
        self.__init__(经度=self.__经度, 纬度=self.__纬度, 坐标系=坐标系)

    @property
    def 有效(self) -> bool:
        有值: bool = self.__坐标系 is not None and self.__经度 is not None and self.__纬度 is not None
        return 有值 and abs(self.__纬度) <= 90

    @property
    def 无效(self) -> bool:
        return not self.有效

    @property
    def 坐标(self) -> tuple[float, float]:
        """
        tuple[经度, 纬度]
        """
        return self.__经度, self.__纬度

    @property
    def gcj02坐标(self) -> tuple[float, float]:
        """
        tuple[经度, 纬度]
        """
        if self.__gcj02坐标.有效:
            return self.__gcj02坐标.坐标
        else:
            self.__gcj02坐标.坐标系 = GPS坐标系类型.gcj02
            if self.__坐标系 in [GPS坐标系类型.wgs84, GPS坐标系类型.智能推理坐标]:
                self.__gcj02坐标.经度, self.__gcj02坐标.纬度 = _wgs2GCJ(self.__经度, self.__纬度)
            elif self.__坐标系 == GPS坐标系类型.gcj02:
                self.__gcj02坐标.经度, self.__gcj02坐标.纬度 = self.坐标
            elif self.__坐标系 == GPS坐标系类型.bd09:
                self.__gcj02坐标.经度, self.__gcj02坐标.纬度 = _bd092GCJ(self.__经度, self.__纬度)
            else:
                self.__gcj02坐标.坐标系 = None

            if self.__gcj02坐标.有效:
                return self.__gcj02坐标.坐标
            else:
                return 0, 0

    @property
    def wgs84坐标(self) -> tuple[float, float]:
        """
        tuple[经度, 纬度]
        """
        if self.__wgs84坐标.有效:
            return self.__wgs84坐标.坐标
        else:
            self.__wgs84坐标.坐标系 = GPS坐标系类型.wgs84
            if self.__坐标系 in [GPS坐标系类型.wgs84, GPS坐标系类型.智能推理坐标]:
                self.__wgs84坐标.经度, self.__wgs84坐标.纬度 = self.坐标
            elif self.__坐标系 == GPS坐标系类型.gcj02:
                self.__wgs84坐标.经度, self.__wgs84坐标.纬度 = _gcj2WGS(self.__经度, self.__纬度)
            elif self.__坐标系 == GPS坐标系类型.bd09:
                self.__wgs84坐标.经度, self.__wgs84坐标.纬度 = _bd092WGS(self.__经度, self.__纬度)
            else:
                self.__wgs84坐标.坐标系 = None

            if self.__wgs84坐标.有效:
                return self.__wgs84坐标.坐标
            else:
                return 0, 0

    @property
    def bd09坐标(self) -> tuple[float, float]:
        """
        tuple[经度, 纬度]
        """
        if self.__bd09坐标.有效:
            return self.__bd09坐标.坐标
        else:
            self.__bd09坐标.坐标系 = GPS坐标系类型.bd09
            if self.__坐标系 in [GPS坐标系类型.wgs84, GPS坐标系类型.智能推理坐标]:
                self.__bd09坐标.经度, self.__bd09坐标.纬度 = _wgs2BD09(self.__经度, self.__纬度)
            elif self.__坐标系 == GPS坐标系类型.gcj02:
                self.__bd09坐标.经度, self.__bd09坐标.纬度 = _gcj2BD09(self.__经度, self.__纬度)
            elif self.__坐标系 == GPS坐标系类型.bd09:
                self.__bd09坐标.经度, self.__bd09坐标.纬度 = self.坐标
            else:
                self.__bd09坐标.坐标系 = None

            if self.__bd09坐标.有效:
                return self.__bd09坐标.坐标
            else:
                return 0, 0

    @property
    def 墨卡托坐标(self) -> 墨卡托坐标类:
        if self.__墨卡托坐标.有效:
            return self.__墨卡托坐标
        else:
            self.__墨卡托坐标.设置坐标(self)
            return self.__墨卡托坐标 if self.__墨卡托坐标.有效 else 墨卡托坐标类(0, 0)

    @property
    def 副本(self) -> 'GPS坐标类':
        副本: GPS坐标类 = GPS坐标类(经度=self.__经度, 纬度=self.__纬度, 坐标系=self.__坐标系)

        return 副本

    # endregion

    def 目标坐标(self, 目标坐标系: GPS坐标系类型 = GPS坐标系类型.智能推理坐标) -> tuple[float, float]:
        """
        计算并返回当前坐标在指定坐标系下的坐标值
        """
        if 目标坐标系 == GPS坐标系类型.gcj02:
            return self.gcj02坐标
        elif 目标坐标系 in [GPS坐标系类型.wgs84, GPS坐标系类型.智能推理坐标]:
            return self.wgs84坐标
        elif 目标坐标系 == GPS坐标系类型.bd09:
            return self.bd09坐标
        else:
            return self.坐标

    class __距离类:
        def __init__(self,
                     m: float = 0):
            self.__m: float = m

        # region 访问器
        @property
        def km(self) -> float:
            return self.__m * 0.001

        @km.setter
        def km(self, 值: float):
            self.__m = 值 * 1000

        @property
        def m(self) -> float:
            return self.__m

        @m.setter
        def m(self, 值: float):
            self.__m = 值

        @property
        def inch(self) -> float:
            return self.__m * 39.3700787402

        @inch.setter
        def inch(self, 值: float):
            self.__m = 值 / 39.3700787402

        @property
        def feet(self) -> float:
            return self.__m * 3.280839895

        @feet.setter
        def feet(self, 值: float):
            self.__m = 值 / 3.280839895

        @property
        def mi(self) -> float:
            return self.__m * 0.00062137119224

        @mi.setter
        def mi(self, 值: float):
            self.__m = 值 / 0.00062137119224

        # endregion

        def __float__(self) -> float:
            return self.__m

    def 球面距离(self, 目标点: 'GPS坐标类') -> __距离类:
        """
        计算本坐标点到指定坐标点之间的球面距离
        """
        if type(目标点) in [GPS坐标类, GPS坐标类.__GPS坐标子类]:
            目标参考点: GPS坐标类 = GPS坐标类(目标点.经度, 目标点.纬度, 目标点.坐标系)
        else:
            return self.__距离类(0)

        if 目标参考点.无效:
            return self.__距离类(0)

        基点坐标经度, 基点坐标纬度 = self.wgs84坐标
        目标点经度, 目标点纬度 = 目标参考点.wgs84坐标

        # 定义GPS距离解算函数
        # 用haversine公式计算球面两点间的距离
        # https://blog.csdn.net/gaocuisheng/article/details/126060795
        # 经纬度转换成弧度
        基点坐标纬度 = _radians(基点坐标纬度)
        目标点纬度 = _radians(目标点纬度)
        基点坐标经度 = _radians(基点坐标经度)
        目标点经度 = _radians(目标点经度)

        经度差 = _fabs(基点坐标经度 - 目标点经度)
        纬度差 = _fabs(基点坐标纬度 - 目标点纬度)

        def _hav(角差: float) -> float:
            s = _sin(角差 / 2)
            return s * s

        h = _hav(纬度差) + _cos(基点坐标纬度) * _cos(目标点纬度) * _hav(经度差)

        return self.__距离类(2 * _earthR * _asin(_sqrt(h)))

    class __倾角类:
        def __init__(self,
                     起点: 'GPS坐标类' = None,
                     终点: 'GPS坐标类' = None,
                     坐标系: GPS坐标系类型 = GPS坐标系类型.智能推理坐标):
            self.__起点: GPS坐标类 = 起点
            self.__终点: GPS坐标类 = 终点
            self.__坐标系: GPS坐标系类型 = 坐标系

        # region 访问器
        @property
        def 有效(self) -> bool:
            return isinstance(self.__起点, GPS坐标类) and self.__起点.有效 and isinstance(self.__终点, GPS坐标类) and self.__终点.有效

        @property
        def 无效(self) -> bool:
            return not self.有效

        @property
        def 墨卡托倾角deg(self) -> float:
            """
            计算本坐标点到指定坐标点之间在墨卡托投影平面下的倾角, 以本坐标点为基准, 以正东方为起点, 逆时针方向为正
            """
            if self.无效:
                return 0

            if self.__坐标系 == GPS坐标系类型.智能推理坐标:
                self.__坐标系 = self.__起点.坐标系

            基点: 墨卡托坐标类 = GPS坐标类(经度=self.__起点.目标坐标(self.__坐标系)[0],
                                           纬度=self.__起点.目标坐标(self.__坐标系)[1],
                                           坐标系=self.__坐标系).墨卡托坐标
            目标点: 墨卡托坐标类 = GPS坐标类(经度=self.__终点.目标坐标(self.__坐标系)[0],
                                             纬度=self.__终点.目标坐标(self.__坐标系)[1],
                                             坐标系=self.__坐标系).墨卡托坐标

            if 基点.无效 or 目标点.无效:
                return 0
            倾角弧度值: float = _atan2(目标点.y - 基点.y, 目标点.x - 基点.x)
            return 倾角弧度值 * 180 / _pi

        @property
        def 地理倾角deg(self) -> float:
            """
            计算本坐标点到指定坐标点之间基于地理距离的倾角, 以本坐标点为基准, 以正东方为起点, 逆时针方向为正
            """
            if self.无效:
                return 0

            if self.__坐标系 == GPS坐标系类型.智能推理坐标:
                self.__坐标系 = self.__起点.坐标系

            基点: GPS坐标类 = GPS坐标类(经度=self.__起点.目标坐标(self.__坐标系)[0],
                                        纬度=self.__起点.目标坐标(self.__坐标系)[1],
                                        坐标系=self.__坐标系)
            目标点: GPS坐标类 = GPS坐标类(经度=self.__终点.目标坐标(self.__坐标系)[0],
                                          纬度=self.__终点.目标坐标(self.__坐标系)[1],
                                          坐标系=self.__坐标系)

            直角点: GPS坐标类 = GPS坐标类(经度=目标点.经度,
                                          纬度=基点.纬度,
                                          坐标系=self.__坐标系)

            if 基点.无效 or 目标点.无效 or 直角点.无效:
                return 0

            纬线长度: float = 基点.球面距离(直角点).m
            if 基点.纬度 > 目标点.纬度:
                纬线长度 *= -1
            经线长度: float = 直角点.球面距离(目标点).m
            if 基点.经度 > 目标点.经度:
                经线长度 *= -1

            倾角弧度: float = _atan2(经线长度, 纬线长度)

            return 倾角弧度 * 180 / _pi

        @property
        def __float__(self) -> float:
            return self.墨卡托倾角deg

        # endregion

    def 倾角(self, 目标点: 'GPS坐标类', 目标坐标系: GPS坐标系类型 = GPS坐标系类型.智能推理坐标) -> __倾角类:
        """
        计算本坐标点到指定坐标点之间的倾角, 以本坐标点为基准, 以正东方为起点, 逆时针方向为正
        """
        return self.__倾角类(起点=self,
                             终点=目标点,
                             坐标系=目标坐标系)

    class __中点类:
        def __init__(self,
                     起点: 'GPS坐标类' = None,
                     终点: 'GPS坐标类' = None,
                     坐标系: GPS坐标系类型 = GPS坐标系类型.智能推理坐标):
            self.__起点: GPS坐标类 = 起点
            self.__终点: GPS坐标类 = 终点
            self.__坐标系: GPS坐标系类型 = 坐标系

        # region 访问器
        @property
        def 有效(self) -> bool:
            return isinstance(self.__起点, GPS坐标类) and self.__起点.有效 and isinstance(self.__终点, GPS坐标类) and self.__终点.有效

        @property
        def 无效(self) -> bool:
            return not self.有效

        @property
        def 墨卡托中点(self) -> 'GPS坐标类':
            """
            计算本坐标点到指定坐标点之间在墨卡托投影平面下, 连线中点位置的GPS坐标
            """
            if self.无效:
                if isinstance(self.__起点, GPS坐标类) and self.__起点.有效:
                    return self.__起点
                elif isinstance(self.__终点, GPS坐标类) and self.__终点.有效:
                    return self.__终点
                else:
                    if isinstance(self.__坐标系, GPS坐标系类型):
                        return GPS坐标类(0, 0, self.__坐标系)
                    else:
                        return GPS坐标类(0, 0, GPS坐标系类型.智能推理坐标)

            if self.__坐标系 == GPS坐标系类型.智能推理坐标:
                self.__坐标系 = self.__起点.坐标系

            基点: 墨卡托坐标类 = GPS坐标类(经度=self.__起点.目标坐标(self.__坐标系)[0],
                                           纬度=self.__起点.目标坐标(self.__坐标系)[1],
                                           坐标系=self.__坐标系).墨卡托坐标
            目标点: 墨卡托坐标类 = GPS坐标类(经度=self.__终点.目标坐标(self.__坐标系)[0],
                                             纬度=self.__终点.目标坐标(self.__坐标系)[1],
                                             坐标系=self.__坐标系).墨卡托坐标
            if 基点.无效 or 目标点.无效:
                return self.__起点

            中点: 墨卡托坐标类 = 墨卡托坐标类(x=(基点.x + 目标点.x) * 0.5,
                                              y=(基点.y + 目标点.y) * 0.5)

            return 中点.GPS坐标(目标坐标系=self.__坐标系)

        # endregion

    def 中点(self, 目标点: 'GPS坐标类', 目标坐标系: GPS坐标系类型 = GPS坐标系类型.智能推理坐标) -> __中点类:
        """
        计算本坐标点到指定坐标点之间, 中点位置的GPS坐标
        """
        return self.__中点类(起点=self,
                             终点=目标点,
                             坐标系=目标坐标系)

    @staticmethod
    def 帮助文档(打印方法: callable = None) -> None:
        画板: _打印模板 = _打印模板()

        画板.添加分隔行('=', None if callable(打印方法) else _黄字)
        画板.添加分隔行('GPS坐标类定义了一个GPS坐标数据结构,包括GPS坐标值,以及GPS坐标系信息')

        if callable(打印方法):
            画板.添加一行('属性', '说明')
        else:
            画板.添加一行('属性', '说明').修饰行(_青字)
        画板.添加一行('经度:', 'GPS坐标的经度值')
        画板.添加一行('纬度:', 'GPS坐标的纬度值')
        画板.添加一行('坐标系:', 'GPS坐标的坐标系信息')
        画板.添加一行('有效:', 'GPS坐标对象的娄提是否有效, 有效为True, 无效为False')
        画板.添加一行('无效:', 'GPS坐标对象的娄提是否无效, 无效为True, 有效为False')
        画板.添加一行('gcj02坐标:', '返回 gcj02 坐标系下的坐标值, tuple(经度, 纬度)')
        画板.添加一行('wgs84坐标:', '返回 wgs84 坐标系下的坐标值, tuple(经度, 纬度)')
        画板.添加一行('bd09坐标:', '返回 bd09 坐标系下的坐标值, tuple(经度, 纬度)')
        画板.添加一行('副本:', '返回一个GPS坐标类对象,数据复制自当前对象')

        画板.添加分隔行('-', None if callable(打印方法) else _黄字)
        if callable(打印方法):
            画板.添加一行('方法', '说明')
        else:
            画板.添加一行('方法', '说明').修饰行(_青字)
        画板.添加一行('目标坐标:', '返回 指定坐标系 下的坐标值, tuple(经度, 纬度)')
        画板.添加一行('球面距离:', '返回 指定GPS坐标类对象位置 和当前GPS坐标对象位置之间的球面距离信息, 可引用m, km, inch, feet等单位')
        画板.添加一行('墨卡托倾角deg:', '返回 指定GPS坐标类对象位置 和当前GPS坐标对象位置之间, 在墨卡托投影下连线的倾斜角度, 单位: 度')
        画板.添加一行('墨卡托中点:', '返回 指定GPS坐标类对象位置 和当前GPS坐标对象位置之间, 在墨卡托投影下连线的中点位置处的GPS坐标类对象')

        画板.添加分隔行('=', None if callable(打印方法) else _黄字)

        画板.展示表格(打印方法=打印方法)


# region 常用GPS坐标整理
# region 常用GPS坐标字典
_常用坐标字典: dict = {'哈尔滨市': GPS坐标类(126.5350, 45.8020, GPS坐标系类型.腾讯地图坐标),
                       '长春市': GPS坐标类(125.3238, 43.8107, GPS坐标系类型.腾讯地图坐标),
                       '沈阳市': GPS坐标类(123.4644, 41.6688, GPS坐标系类型.腾讯地图坐标),
                       '北京市': GPS坐标类(116.4111, 39.8971, GPS坐标系类型.腾讯地图坐标),
                       '呼和浩特市': GPS坐标类(111.7529, 40.8471, GPS坐标系类型.腾讯地图坐标),
                       '乌鲁木齐市': GPS坐标类(87.6132, 43.8226, GPS坐标系类型.腾讯地图坐标),
                       '石家庄市': GPS坐标类(114.5160, 38.0373, GPS坐标系类型.腾讯地图坐标),
                       '天津市': GPS坐标类(117.2021, 39.0874, GPS坐标系类型.腾讯地图坐标),
                       '太原市': GPS坐标类(112.5494, 37.8683, GPS坐标系类型.腾讯地图坐标),
                       '银川市': GPS坐标类(106.2323, 38.4815, GPS坐标系类型.腾讯地图坐标),
                       '济南市': GPS坐标类(117.1198, 36.6508, GPS坐标系类型.腾讯地图坐标),
                       '西宁市': GPS坐标类(101.7773, 36.6133, GPS坐标系类型.腾讯地图坐标),
                       '兰州市': GPS坐标类(103.8345, 36.0602, GPS坐标系类型.腾讯地图坐标),
                       '郑州市': GPS坐标类(113.6234, 34.7394, GPS坐标系类型.腾讯地图坐标),
                       '西安市': GPS坐标类(108.9404, 34.3366, GPS坐标系类型.腾讯地图坐标),
                       '南京市': GPS坐标类(118.7952, 32.0616, GPS坐标系类型.腾讯地图坐标),
                       '合肥市': GPS坐标类(117.2269, 31.8146, GPS坐标系类型.腾讯地图坐标),
                       '上海市': GPS坐标类(121.4758, 31.2245, GPS坐标系类型.腾讯地图坐标),
                       '武汉市': GPS坐标类(114.3045, 30.5859, GPS坐标系类型.腾讯地图坐标),
                       '成都市': GPS坐标类(104.0652, 30.5646, GPS坐标系类型.腾讯地图坐标),
                       '杭州市': GPS坐标类(120.2069, 30.2425, GPS坐标系类型.腾讯地图坐标),
                       '重庆市': GPS坐标类(106.5536, 29.5567, GPS坐标系类型.腾讯地图坐标),
                       '拉萨市': GPS坐标类(91.1728, 29.6523, GPS坐标系类型.腾讯地图坐标),
                       '南昌市': GPS坐标类(115.8563, 28.6785, GPS坐标系类型.腾讯地图坐标),
                       '长沙市': GPS坐标类(112.9395, 28.2294, GPS坐标系类型.腾讯地图坐标),
                       '贵阳市': GPS坐标类(106.6251, 26.6450, GPS坐标系类型.腾讯地图坐标),
                       '昆明市': GPS坐标类(102.8348, 24.8740, GPS坐标系类型.腾讯地图坐标),
                       '福州市': GPS坐标类(119.2950, 26.0667, GPS坐标系类型.腾讯地图坐标),
                       '台北市': GPS坐标类(121.5088, 25.0408, GPS坐标系类型.腾讯地图坐标),
                       '广州市': GPS坐标类(113.2608, 23.1328, GPS坐标系类型.腾讯地图坐标),
                       '南宁市': GPS坐标类(108.3691, 22.8116, GPS坐标系类型.腾讯地图坐标),
                       '澳门特别行政区': GPS坐标类(113.5437, 22.1721, GPS坐标系类型.腾讯地图坐标),
                       '香港特别行政区': GPS坐标类(114.1699, 22.2688, GPS坐标系类型.腾讯地图坐标),
                       '海口市': GPS坐标类(110.1984, 20.0508, GPS坐标系类型.腾讯地图坐标),
                       '曾母暗沙': GPS坐标类(112.2916, 3.9800, GPS坐标系类型.腾讯地图坐标),
                       '南沙群岛': GPS坐标类(115.4182, 9.7514, GPS坐标系类型.腾讯地图坐标),
                       '黄岩岛': GPS坐标类(117.7570, 15.1450, GPS坐标系类型.腾讯地图坐标),
                       '三沙市': GPS坐标类(112.3386, 16.8246, GPS坐标系类型.腾讯地图坐标),
                       '钓鱼岛': GPS坐标类(123.5825, 25.8370, GPS坐标系类型.腾讯地图坐标),
                       '赤尾屿': GPS坐标类(124.5493, 25.9210, GPS坐标系类型.腾讯地图坐标),
                       '黑瞎子岛': GPS坐标类(134.6982, 48.3382, GPS坐标系类型.腾讯地图坐标),
                       '伊春市': GPS坐标类(128.8394, 47.7245, GPS坐标系类型.腾讯地图坐标),
                       '鹤岗市': GPS坐标类(130.2951, 47.3463, GPS坐标系类型.腾讯地图坐标),
                       '佳木斯市': GPS坐标类(130.3198, 46.7944, GPS坐标系类型.腾讯地图坐标),
                       '双鸭山市': GPS坐标类(131.1411, 46.6758, GPS坐标系类型.腾讯地图坐标),
                       '七台河市': GPS坐标类(131.0037, 45.7694, GPS坐标系类型.腾讯地图坐标),
                       '鸡西市': GPS坐标类(130.9653, 45.2923, GPS坐标系类型.腾讯地图坐标),
                       '牡丹江市': GPS坐标类(129.6304, 44.5455, GPS坐标系类型.腾讯地图坐标),
                       '绥化市': GPS坐标类(126.9662, 46.6494, GPS坐标系类型.腾讯地图坐标),
                       '大庆市': GPS坐标类(125.1041, 46.5853, GPS坐标系类型.腾讯地图坐标),
                       '齐齐哈尔市': GPS坐标类(123.9148, 47.3556, GPS坐标系类型.腾讯地图坐标),
                       '白城市': GPS坐标类(122.8271, 45.6064, GPS坐标系类型.腾讯地图坐标),
                       '松原市': GPS坐标类(124.8239, 45.1394, GPS坐标系类型.腾讯地图坐标),
                       '吉林市': GPS坐标类(126.5460, 43.8385, GPS坐标系类型.腾讯地图坐标),
                       '延边朝鲜族自治州': GPS坐标类(129.4656, 42.9182, GPS坐标系类型.腾讯地图坐标),
                       '辽源市': GPS坐标类(125.1425, 42.8840, GPS坐标系类型.腾讯地图坐标),
                       '四平市': GPS坐标类(124.3433, 43.1651, GPS坐标系类型.腾讯地图坐标),
                       '白山市': GPS坐标类(126.4142, 41.9391, GPS坐标系类型.腾讯地图坐标),
                       '通化市': GPS坐标类(125.9363, 41.7324, GPS坐标系类型.腾讯地图坐标),
                       '铁岭市': GPS坐标类(123.7280, 42.2163, GPS坐标系类型.腾讯地图坐标),
                       '抚顺市': GPS坐标类(123.9532, 41.8777, GPS坐标系类型.腾讯地图坐标),
                       '本溪市': GPS坐标类(123.6786, 41.4798, GPS坐标系类型.腾讯地图坐标),
                       '辽阳市': GPS坐标类(123.2364, 41.2695, GPS坐标系类型.腾讯地图坐标),
                       '鞍山市': GPS坐标类(122.9947, 41.1083, GPS坐标系类型.腾讯地图坐标),
                       '盘锦市': GPS坐标类(122.1680, 40.7181, GPS坐标系类型.腾讯地图坐标),
                       '营口市': GPS坐标类(122.2174, 40.6244, GPS坐标系类型.腾讯地图坐标),
                       '阜新市': GPS坐标类(121.6708, 42.0228, GPS坐标系类型.腾讯地图坐标),
                       '朝阳市': GPS坐标类(120.4871, 41.6011, GPS坐标系类型.腾讯地图坐标),
                       '锦州市': GPS坐标类(121.1243, 41.0897, GPS坐标系类型.腾讯地图坐标),
                       '葫芦岛市': GPS坐标类(120.8331, 40.7098, GPS坐标系类型.腾讯地图坐标),
                       '大连市': GPS坐标类(121.6132, 38.9039, GPS坐标系类型.腾讯地图坐标),
                       '秦皇岛市': GPS坐标类(119.5148, 39.8887, GPS坐标系类型.腾讯地图坐标),
                       '承德市': GPS坐标类(117.9547, 40.9467, GPS坐标系类型.腾讯地图坐标),
                       '唐山市': GPS坐标类(118.1799, 39.6268, GPS坐标系类型.腾讯地图坐标),
                       '张家口市': GPS坐标类(114.8840, 40.7618, GPS坐标系类型.腾讯地图坐标),
                       '雄安新区': GPS坐标类(115.9140, 39.0427, GPS坐标系类型.腾讯地图坐标),
                       '保定市': GPS坐标类(115.4636, 38.8718, GPS坐标系类型.腾讯地图坐标),
                       '沧州市': GPS坐标类(116.8369, 38.3072, GPS坐标系类型.腾讯地图坐标),
                       '衡水市': GPS坐标类(115.6668, 37.7425, GPS坐标系类型.腾讯地图坐标),
                       '邢台市': GPS坐标类(114.4968, 37.0552, GPS坐标系类型.腾讯地图坐标),
                       '邯郸市': GPS坐标类(114.5352, 36.6221, GPS坐标系类型.腾讯地图坐标),
                       '大同市': GPS坐标类(113.3679, 40.0949, GPS坐标系类型.腾讯地图坐标),
                       '朔州市': GPS坐标类(112.4313, 39.3258, GPS坐标系类型.腾讯地图坐标),
                       '忻州市': GPS坐标类(112.7307, 38.4127, GPS坐标系类型.腾讯地图坐标),
                       '阳泉市': GPS坐标类(113.5767, 37.8532, GPS坐标系类型.腾讯地图坐标),
                       '晋中市': GPS坐标类(112.7499, 37.6882, GPS坐标系类型.腾讯地图坐标),
                       '吕梁市': GPS坐标类(111.1459, 37.5184, GPS坐标系类型.腾讯地图坐标),
                       '临汾市': GPS坐标类(111.5195, 36.0891, GPS坐标系类型.腾讯地图坐标),
                       '长治市': GPS坐标类(113.1180, 36.1955, GPS坐标系类型.腾讯地图坐标),
                       '晋城市': GPS坐标类(112.8488, 35.4920, GPS坐标系类型.腾讯地图坐标),
                       '运城市': GPS坐标类(111.0059, 35.0255, GPS坐标系类型.腾讯地图坐标),
                       '榆林市': GPS坐标类(109.7314, 38.2813, GPS坐标系类型.腾讯地图坐标),
                       '延安市': GPS坐标类(109.4925, 36.6508, GPS坐标系类型.腾讯地图坐标),
                       '铜川市': GPS坐标类(108.9432, 34.8972, GPS坐标系类型.腾讯地图坐标),
                       '渭南市': GPS坐标类(109.4705, 34.5247, GPS坐标系类型.腾讯地图坐标),
                       '咸阳市': GPS坐标类(108.7097, 34.3253, GPS坐标系类型.腾讯地图坐标),
                       '商洛市': GPS坐标类(109.9182, 33.8773, GPS坐标系类型.腾讯地图坐标),
                       '安康市': GPS坐标类(109.0256, 32.6833, GPS坐标系类型.腾讯地图坐标),
                       '汉中市': GPS坐标类(107.0233, 33.0685, GPS坐标系类型.腾讯地图坐标),
                       '宝鸡市': GPS坐标类(107.2375, 34.3684, GPS坐标系类型.腾讯地图坐标),
                       '石嘴山市': GPS坐标类(106.3806, 38.9850, GPS坐标系类型.腾讯地图坐标),
                       '吴忠市': GPS坐标类(106.1966, 37.9940, GPS坐标系类型.腾讯地图坐标),
                       '中卫市': GPS坐标类(105.1968, 37.5032, GPS坐标系类型.腾讯地图坐标),
                       '固原市': GPS坐标类(106.2405, 36.0136, GPS坐标系类型.腾讯地图坐标),
                       '庆阳市': GPS坐标类(107.6413, 35.7041, GPS坐标系类型.腾讯地图坐标),
                       '平凉市': GPS坐标类(106.6608, 35.5389, GPS坐标系类型.腾讯地图坐标),
                       '天水市': GPS坐标类(105.7214, 34.5767, GPS坐标系类型.腾讯地图坐标),
                       '陇南市': GPS坐标类(104.9579, 33.3695, GPS坐标系类型.腾讯地图坐标),
                       '定西市': GPS坐标类(104.5898, 35.6037, GPS坐标系类型.腾讯地图坐标),
                       '白银市': GPS坐标类(104.1367, 36.5427, GPS坐标系类型.腾讯地图坐标),
                       '海东市': GPS坐标类(102.4063, 36.4721, GPS坐标系类型.腾讯地图坐标),
                       '武威市': GPS坐标类(102.6343, 37.9269, GPS坐标系类型.腾讯地图坐标),
                       '金昌市': GPS坐标类(102.1893, 38.5202, GPS坐标系类型.腾讯地图坐标),
                       '张掖市': GPS坐标类(100.4480, 38.9231, GPS坐标系类型.腾讯地图坐标),
                       '酒泉市': GPS坐标类(98.4924, 39.7325, GPS坐标系类型.腾讯地图坐标),
                       '嘉峪关市': GPS坐标类(98.2864, 39.7663, GPS坐标系类型.腾讯地图坐标),
                       '哈密市': GPS坐标类(93.5129, 42.8156, GPS坐标系类型.腾讯地图坐标),
                       '新星市': GPS坐标类(93.7463, 42.7974, GPS坐标系类型.腾讯地图坐标),
                       '吐鲁番市': GPS坐标类(89.1870, 42.9464, GPS坐标系类型.腾讯地图坐标),
                       '胡杨河市': GPS坐标类(84.8282, 44.6921, GPS坐标系类型.腾讯地图坐标),
                       '克拉玛依市': GPS坐标类(84.8859, 45.5794, GPS坐标系类型.腾讯地图坐标),
                       '阿勒泰地区': GPS坐标类(88.1488, 47.8869, GPS坐标系类型.腾讯地图坐标),
                       '博尔塔拉蒙古自治州': GPS坐标类(82.0662, 44.9055, GPS坐标系类型.腾讯地图坐标),
                       '伊犁哈萨克自治州': GPS坐标类(81.3019, 43.9199, GPS坐标系类型.腾讯地图坐标),
                       '阿克苏地区': GPS坐标类(80.2428, 41.1781, GPS坐标系类型.腾讯地图坐标),
                       '客什地区': GPS坐标类(75.9905, 39.4715, GPS坐标系类型.腾讯地图坐标),
                       '和田地区': GPS坐标类(79.9451, 37.0974, GPS坐标系类型.腾讯地图坐标),
                       '大兴安岭地区': GPS坐标类(124.1513, 50.4389, GPS坐标系类型.腾讯地图坐标),
                       '呼伦贝尔市': GPS坐标类(119.7784, 49.1673, GPS坐标系类型.腾讯地图坐标),
                       '通辽市': GPS坐标类(122.2421, 43.6579, GPS坐标系类型.腾讯地图坐标),
                       '赤峰市': GPS坐标类(118.8858, 42.2570, GPS坐标系类型.腾讯地图坐标),
                       '乌兰察布市': GPS坐标类(113.1317, 40.9944, GPS坐标系类型.腾讯地图坐标),
                       '包头市': GPS坐标类(109.9512, 40.6223, GPS坐标系类型.腾讯地图坐标),
                       '鄂尔多斯市': GPS坐标类(109.7809, 39.6036, GPS坐标系类型.腾讯地图坐标),
                       '巴彦淖尔市': GPS坐标类(107.3859, 40.7452, GPS坐标系类型.腾讯地图坐标),
                       '乌海市': GPS坐标类(106.7926, 39.6565, GPS坐标系类型.腾讯地图坐标),
                       '阿里地区': GPS坐标类(80.1061, 32.5063, GPS坐标系类型.腾讯地图坐标),
                       '日客则市': GPS坐标类(88.8794, 29.2648, GPS坐标系类型.腾讯地图坐标),
                       '山南市': GPS坐标类(91.7688, 29.2409, GPS坐标系类型.腾讯地图坐标),
                       '林芝市': GPS坐标类(94.3588, 29.6475, GPS坐标系类型.腾讯地图坐标),
                       '那曲市': GPS坐标类(92.0517, 31.4802, GPS坐标系类型.腾讯地图坐标),
                       '昌都市': GPS坐标类(97.1713, 31.1376, GPS坐标系类型.腾讯地图坐标),
                       '珠穆拉玛峰': GPS坐标类(86.9305, 27.9869, GPS坐标系类型.腾讯地图坐标),
                       '安阳市': GPS坐标类(114.3924, 36.0979, GPS坐标系类型.腾讯地图坐标),
                       '鹤壁市': GPS坐标类(114.2935, 35.7443, GPS坐标系类型.腾讯地图坐标),
                       '焦作市': GPS坐标类(113.2388, 35.2142, GPS坐标系类型.腾讯地图坐标),
                       '三门峡市': GPS坐标类(111.2009, 34.7709, GPS坐标系类型.腾讯地图坐标),
                       '濮阳市': GPS坐标类(115.0269, 35.7599, GPS坐标系类型.腾讯地图坐标),
                       '新乡市': GPS坐标类(113.9227, 35.2994, GPS坐标系类型.腾讯地图坐标),
                       '开封市': GPS坐标类(114.3127, 34.7935, GPS坐标系类型.腾讯地图坐标),
                       '洛阳市': GPS坐标类(112.4533, 34.6242, GPS坐标系类型.腾讯地图坐标),
                       '商丘市': GPS坐标类(115.6531, 34.4137, GPS坐标系类型.腾讯地图坐标),
                       '许昌市': GPS坐标类(113.8486, 34.0345, GPS坐标系类型.腾讯地图坐标),
                       '平顶山市': GPS坐标类(113.1894, 33.7632, GPS坐标系类型.腾讯地图坐标),
                       '周口市': GPS坐标类(114.6973, 33.6329, GPS坐标系类型.腾讯地图坐标),
                       '漯河市': GPS坐标类(114.0134, 33.5757, GPS坐标系类型.腾讯地图坐标),
                       '南阳市': GPS坐标类(112.5247, 32.9879, GPS坐标系类型.腾讯地图坐标),
                       '驻马店市': GPS坐标类(114.0216, 33.0133, GPS坐标系类型.腾讯地图坐标),
                       '信阳市': GPS坐标类(114.0930, 32.1524, GPS坐标系类型.腾讯地图坐标),
                       '德州市': GPS坐标类(116.3589, 37.4313, GPS坐标系类型.腾讯地图坐标),
                       '滨州市': GPS坐标类(117.9684, 37.3876, GPS坐标系类型.腾讯地图坐标),
                       '东营市': GPS坐标类(118.6716, 37.4334, GPS坐标系类型.腾讯地图坐标),
                       '烟台市': GPS坐标类(121.4456, 37.4618, GPS坐标系类型.腾讯地图坐标),
                       '威海市': GPS坐标类(122.1185, 37.5119, GPS坐标系类型.腾讯地图坐标),
                       '潍坊市': GPS坐标类(119.1577, 36.7147, GPS坐标系类型.腾讯地图坐标),
                       '淄博市': GPS坐标类(118.0563, 36.8159, GPS坐标系类型.腾讯地图坐标),
                       '聊城市': GPS坐标类(115.9827, 36.4611, GPS坐标系类型.腾讯地图坐标),
                       '泰安市': GPS坐标类(117.0868, 36.2022, GPS坐标系类型.腾讯地图坐标),
                       '青岛市': GPS坐标类(120.3799, 36.0713, GPS坐标系类型.腾讯地图坐标),
                       '菏泽市': GPS坐标类(115.4800, 35.2389, GPS坐标系类型.腾讯地图坐标),
                       '济宁市': GPS坐标类(116.5842, 35.4159, GPS坐标系类型.腾讯地图坐标),
                       '日照市': GPS坐标类(119.5258, 35.4182, GPS坐标系类型.腾讯地图坐标),
                       '临沂市': GPS坐标类(118.3557, 35.1109, GPS坐标系类型.腾讯地图坐标),
                       '枣庄市': GPS坐标类(117.3203, 34.8138, GPS坐标系类型.腾讯地图坐标),
                       '连云港市': GPS坐标类(119.2181, 34.5970, GPS坐标系类型.腾讯地图坐标),
                       '徐州市': GPS坐标类(117.2818, 34.2050, GPS坐标系类型.腾讯地图坐标),
                       '宿迁市': GPS坐标类(118.2733, 33.9639, GPS坐标系类型.腾讯地图坐标),
                       '淮安市': GPS坐标类(119.1138, 33.5528, GPS坐标系类型.腾讯地图坐标),
                       '盐城市': GPS坐标类(120.1630, 33.3512, GPS坐标系类型.腾讯地图坐标),
                       '泰州市': GPS坐标类(119.9240, 32.4565, GPS坐标系类型.腾讯地图坐标),
                       '杨州市': GPS坐标类(119.4104, 32.3985, GPS坐标系类型.腾讯地图坐标),
                       '镇江市': GPS坐标类(119.4241, 32.1919, GPS坐标系类型.腾讯地图坐标),
                       '南通市': GPS坐标类(120.8936, 31.9778, GPS坐标系类型.腾讯地图坐标),
                       '常州市': GPS坐标类(119.9734, 31.8122, GPS坐标系类型.腾讯地图坐标),
                       '苏州市': GPS坐标类(120.5832, 31.3044, GPS坐标系类型.腾讯地图坐标),
                       '无锡市': GPS坐标类(120.3085, 31.4989, GPS坐标系类型.腾讯地图坐标),
                       '太湖': GPS坐标类(120.2601, 31.2132, GPS坐标系类型.高德地图坐标),
                       '昆山市': GPS坐标类(120.9808, 31.3839, GPS坐标系类型.腾讯地图坐标),
                       '淮北市': GPS坐标类(116.7957, 33.9616, GPS坐标系类型.腾讯地图坐标),
                       '亳州市': GPS坐标类(115.7767, 33.8453, GPS坐标系类型.腾讯地图坐标),
                       '阜阳市': GPS坐标类(115.8124, 32.8911, GPS坐标系类型.腾讯地图坐标),
                       '蚌埠市': GPS坐标类(117.3889, 32.9188, GPS坐标系类型.腾讯地图坐标),
                       '淮南市': GPS坐标类(117.0154, 32.5908, GPS坐标系类型.腾讯地图坐标),
                       '六安市': GPS坐标类(116.5210, 31.7375, GPS坐标系类型.腾讯地图坐标),
                       '滁州市': GPS坐标类(118.3310, 32.2546, GPS坐标系类型.腾讯地图坐标),
                       '马鞍山市': GPS坐标类(118.5040, 31.6721, GPS坐标系类型.腾讯地图坐标),
                       '芜湖市': GPS坐标类(118.4299, 31.3560, GPS坐标系类型.腾讯地图坐标),
                       '宣城市': GPS坐标类(118.7567, 30.9399, GPS坐标系类型.腾讯地图坐标),
                       '铜陵市': GPS坐标类(117.8119, 30.9470, GPS坐标系类型.腾讯地图坐标),
                       '池州市': GPS坐标类(117.4933, 30.6757, GPS坐标系类型.腾讯地图坐标),
                       '安庆市': GPS坐标类(117.1143, 30.5339, GPS坐标系类型.腾讯地图坐标),
                       '黄山市': GPS坐标类(118.3365, 29.7143, GPS坐标系类型.腾讯地图坐标),
                       '黄山风景区': GPS坐标类(118.1566, 30.1558, GPS坐标系类型.腾讯地图坐标),
                       '鄂州市': GPS坐标类(114.8923, 30.3918, GPS坐标系类型.腾讯地图坐标),
                       '咸宁市': GPS坐标类(114.3210, 29.8430, GPS坐标系类型.腾讯地图坐标),
                       '孝感市': GPS坐标类(113.9557, 30.9234, GPS坐标系类型.腾讯地图坐标),
                       '随州市': GPS坐标类(113.3817, 31.6955, GPS坐标系类型.腾讯地图坐标),
                       '荆门市': GPS坐标类(112.1951, 31.0341, GPS坐标系类型.腾讯地图坐标),
                       '荆州市': GPS坐标类(112.2391, 30.3444, GPS坐标系类型.腾讯地图坐标),
                       '襄阳市': GPS坐标类(112.1210, 32.0127, GPS坐标系类型.腾讯地图坐标),
                       '宜昌市': GPS坐标类(111.2860, 30.6970, GPS坐标系类型.腾讯地图坐标),
                       '十堰市': GPS坐标类(110.7971, 32.6324, GPS坐标系类型.腾讯地图坐标),
                       '恩施土家族苗族自治州': GPS坐标类(109.4882, 30.2724, GPS坐标系类型.腾讯地图坐标),
                       '黄石市': GPS坐标类(115.0378, 30.1997, GPS坐标系类型.腾讯地图坐标),
                       '黄冈市': GPS坐标类(114.8703, 30.4534, GPS坐标系类型.腾讯地图坐标),
                       '广元市': GPS坐标类(105.8423, 32.4402, GPS坐标系类型.腾讯地图坐标),
                       '巴中市': GPS坐标类(106.7487, 31.8659, GPS坐标系类型.腾讯地图坐标),
                       '达州市': GPS坐标类(107.4683, 31.2081, GPS坐标系类型.腾讯地图坐标),
                       '广安市': GPS坐标类(106.6333, 30.4558, GPS坐标系类型.腾讯地图坐标),
                       '南充市': GPS坐标类(106.1087, 30.8339, GPS坐标系类型.腾讯地图坐标),
                       '绵阳市': GPS坐标类(104.6805, 31.4708, GPS坐标系类型.腾讯地图坐标),
                       '德阳市': GPS坐标类(104.3948, 31.1329, GPS坐标系类型.腾讯地图坐标),
                       '遂宁市': GPS坐标类(105.5923, 30.5386, GPS坐标系类型.腾讯地图坐标),
                       '资阳市': GPS坐标类(104.6255, 30.1309, GPS坐标系类型.腾讯地图坐标),
                       '内江市': GPS坐标类(105.0568, 29.5806, GPS坐标系类型.腾讯地图坐标),
                       '泸州市': GPS坐标类(105.4413, 28.8711, GPS坐标系类型.腾讯地图坐标),
                       '宜宾市': GPS坐标类(104.6420, 28.7508, GPS坐标系类型.腾讯地图坐标),
                       '自贡市': GPS坐标类(104.7794, 29.3415, GPS坐标系类型.腾讯地图坐标),
                       '乐山市': GPS坐标类(103.7631, 29.5615, GPS坐标系类型.腾讯地图坐标),
                       '眉山市': GPS坐标类(103.8455, 30.0762, GPS坐标系类型.腾讯地图坐标),
                       '雅安市': GPS坐标类(103.0380, 30.0144, GPS坐标系类型.腾讯地图坐标),
                       '攀枝花市': GPS坐标类(101.7169, 26.5885, GPS坐标系类型.腾讯地图坐标),
                       '阿贝藏族羌族自治州': GPS坐标类(102.2226, 31.8999, GPS坐标系类型.腾讯地图坐标),
                       '甘孜藏族自治州': GPS坐标类(101.9640, 30.0505, GPS坐标系类型.腾讯地图坐标),
                       '凉山彝族自治州': GPS坐标类(102.2644, 27.8702, GPS坐标系类型.腾讯地图坐标),
                       '昭通市': GPS坐标类(103.7109, 27.3425, GPS坐标系类型.腾讯地图坐标),
                       '曲靖市': GPS坐标类(103.7933, 25.4978, GPS坐标系类型.腾讯地图坐标),
                       '丽江市': GPS坐标类(100.2228, 26.8584, GPS坐标系类型.腾讯地图坐标),
                       '保山市': GPS坐标类(99.1571, 25.1204, GPS坐标系类型.腾讯地图坐标),
                       '临沧市': GPS坐标类(100.0854, 23.8909, GPS坐标系类型.腾讯地图坐标),
                       '玉溪市': GPS坐标类(102.5244, 24.3571, GPS坐标系类型.腾讯地图坐标),
                       '普洱市': GPS坐标类(100.9589, 22.8319, GPS坐标系类型.腾讯地图坐标),
                       '迪庆藏族自治州': GPS坐标类(99.7021, 27.8192, GPS坐标系类型.腾讯地图坐标),
                       '大理白族自治州': GPS坐标类(100.2676, 25.6065, GPS坐标系类型.腾讯地图坐标),
                       '楚雄彝族自治州': GPS坐标类(101.5182, 25.0578, GPS坐标系类型.腾讯地图坐标),
                       '怒江傈傈族自治州': GPS坐标类(98.8561, 25.8440, GPS坐标系类型.腾讯地图坐标),
                       '德宏傣族景颇族自治州': GPS坐标类(98.5774, 24.4410, GPS坐标系类型.腾讯地图坐标),
                       '红河哈尼族彝族自治州': GPS坐标类(103.3750, 23.3630, GPS坐标系类型.腾讯地图坐标),
                       '文山壮族苗族自治州': GPS坐标类(104.2173, 23.3990, GPS坐标系类型.腾讯地图坐标),
                       '西双版纳傣族自治州': GPS坐标类(100.7994, 22.0117, GPS坐标系类型.腾讯地图坐标),
                       '遵义市': GPS坐标类(107.0288, 27.7273, GPS坐标系类型.腾讯地图坐标),
                       '毕节市': GPS坐标类(105.2902, 27.2815, GPS坐标系类型.腾讯地图坐标),
                       '六盘水市': GPS坐标类(104.8288, 26.5959, GPS坐标系类型.腾讯地图坐标),
                       '铜仁市': GPS坐标类(109.1904, 27.7370, GPS坐标系类型.腾讯地图坐标),
                       '安顺市': GPS坐标类(105.9439, 26.2565, GPS坐标系类型.腾讯地图坐标),
                       '黔东南苗族侗族自治州': GPS坐标类(107.9828, 26.5838, GPS坐标系类型.腾讯地图坐标),
                       '黔南布依族苗族自治州': GPS坐标类(107.5141, 26.2624, GPS坐标系类型.腾讯地图坐标),
                       '岳阳市': GPS坐标类(113.1262, 29.3582, GPS坐标系类型.腾讯地图坐标),
                       '张家界市': GPS坐标类(110.4758, 29.1162, GPS坐标系类型.腾讯地图坐标),
                       '常德市': GPS坐标类(111.6980, 29.0322, GPS坐标系类型.腾讯地图坐标),
                       '益阳市': GPS坐标类(112.3572, 28.5508, GPS坐标系类型.腾讯地图坐标),
                       '湘潭市': GPS坐标类(112.9449, 27.8269, GPS坐标系类型.腾讯地图坐标),
                       '株州市': GPS坐标类(113.1262, 27.8342, GPS坐标系类型.腾讯地图坐标),
                       '娄底市': GPS坐标类(111.9946, 27.6981, GPS坐标系类型.腾讯地图坐标),
                       '邵阳市': GPS坐标类(111.4700, 27.2400, GPS坐标系类型.腾讯地图坐标),
                       '衡阳市': GPS坐标类(112.5714, 26.8951, GPS坐标系类型.腾讯地图坐标),
                       '怀化市': GPS坐标类(110.0006, 27.5716, GPS坐标系类型.腾讯地图坐标),
                       '永州市': GPS坐标类(111.6129, 26.4189, GPS坐标系类型.腾讯地图坐标),
                       '郴州市': GPS坐标类(113.0164, 25.7727, GPS坐标系类型.腾讯地图坐标),
                       '湘西土家族苗族自治州': GPS坐标类(109.7351, 28.3160, GPS坐标系类型.腾讯地图坐标),
                       '九江市': GPS坐标类(115.9497, 29.6666, GPS坐标系类型.腾讯地图坐标),
                       '景德镇市': GPS坐标类(117.1857, 29.2720, GPS坐标系类型.腾讯地图坐标),
                       '上饶市': GPS坐标类(117.9410, 28.4614, GPS坐标系类型.腾讯地图坐标),
                       '鹰潭市': GPS坐标类(117.0374, 28.2802, GPS坐标系类型.腾讯地图坐标),
                       '抚州市': GPS坐标类(116.3562, 27.9556, GPS坐标系类型.腾讯地图坐标),
                       '新余市': GPS坐标类(114.9170, 27.8269, GPS坐标系类型.腾讯地图坐标),
                       '宜春市': GPS坐标类(114.4144, 27.8196, GPS坐标系类型.腾讯地图坐标),
                       '萍乡市': GPS坐标类(113.8870, 27.6689, GPS坐标系类型.腾讯地图坐标),
                       '吉安市': GPS坐标类(114.9664, 27.0885, GPS坐标系类型.腾讯地图坐标),
                       '赣州市': GPS坐标类(114.9307, 25.8345, GPS坐标系类型.腾讯地图坐标),
                       '湖州市': GPS坐标类(120.0833, 30.8952, GPS坐标系类型.腾讯地图坐标),
                       '嘉兴市': GPS坐标类(120.7562, 30.7536, GPS坐标系类型.腾讯地图坐标),
                       '绍兴市': GPS坐标类(120.5804, 30.0501, GPS坐标系类型.腾讯地图坐标),
                       '舟山市': GPS坐标类(122.2064, 29.9859, GPS坐标系类型.腾讯地图坐标),
                       '宁波市': GPS坐标类(121.6214, 29.8597, GPS坐标系类型.腾讯地图坐标),
                       '金华市': GPS坐标类(119.6466, 29.0826, GPS坐标系类型.腾讯地图坐标),
                       '衢州市': GPS坐标类(118.8583, 28.9697, GPS坐标系类型.腾讯地图坐标),
                       '丽水市': GPS坐标类(119.9240, 28.4663, GPS坐标系类型.腾讯地图坐标),
                       '台州市': GPS坐标类(121.4182, 28.6569, GPS坐标系类型.腾讯地图坐标),
                       '温州市': GPS坐标类(120.6985, 27.9920, GPS坐标系类型.腾讯地图坐标),
                       '桂林市': GPS坐标类(110.1791, 25.2397, GPS坐标系类型.腾讯地图坐标),
                       '贺州市': GPS坐标类(111.5689, 24.4096, GPS坐标系类型.腾讯地图坐标),
                       '河池市': GPS坐标类(108.6328, 24.4896, GPS坐标系类型.腾讯地图坐标),
                       '柳州市': GPS坐标类(109.4293, 24.3321, GPS坐标系类型.腾讯地图坐标),
                       '梧州市': GPS坐标类(111.2778, 23.4859, GPS坐标系类型.腾讯地图坐标),
                       '来宾市': GPS坐标类(109.2206, 23.7552, GPS坐标系类型.腾讯地图坐标),
                       '贵港市': GPS坐标类(109.5969, 23.1126, GPS坐标系类型.腾讯地图坐标),
                       '玉林市': GPS坐标类(110.1791, 22.6495, GPS坐标系类型.腾讯地图坐标),
                       '崇左市': GPS坐标类(107.3611, 22.3729, GPS坐标系类型.腾讯地图坐标),
                       '防城巷市': GPS坐标类(108.3527, 21.6855, GPS坐标系类型.腾讯地图坐标),
                       '钦州市': GPS坐标类(108.6548, 21.9813, GPS坐标系类型.腾讯地图坐标),
                       '北海市': GPS坐标类(109.1176, 21.4825, GPS坐标系类型.腾讯地图坐标),
                       '百色市': GPS坐标类(106.6196, 23.9109, GPS坐标系类型.腾讯地图坐标),
                       '韶关市': GPS坐标类(113.5959, 24.8191, GPS坐标系类型.腾讯地图坐标),
                       '梅州市': GPS坐标类(116.1227, 24.2845, GPS坐标系类型.腾讯地图坐标),
                       '河源市': GPS坐标类(114.6973, 23.7401, GPS坐标系类型.腾讯地图坐标),
                       '清远市': GPS坐标类(113.0521, 23.6823, GPS坐标系类型.腾讯地图坐标),
                       '肇庆市': GPS坐标类(112.4615, 23.0469, GPS坐标系类型.腾讯地图坐标),
                       '佛山市': GPS坐标类(113.1207, 23.0165, GPS坐标系类型.腾讯地图坐标),
                       '中山市': GPS坐标类(113.3926, 22.5176, GPS坐标系类型.腾讯地图坐标),
                       '惠州市': GPS坐标类(114.4144, 23.1100, GPS坐标系类型.腾讯地图坐标),
                       '珠海市': GPS坐标类(113.5767, 22.2688, GPS坐标系类型.腾讯地图坐标),
                       '云浮市': GPS坐标类(112.0441, 22.9154, GPS坐标系类型.腾讯地图坐标),
                       '东莞市': GPS坐标类(113.7524, 23.0241, GPS坐标系类型.腾讯地图坐标),
                       '潮州市': GPS坐标类(116.6226, 23.6546, GPS坐标系类型.腾讯地图坐标),
                       '汕头市': GPS坐标类(116.6803, 23.3523, GPS坐标系类型.腾讯地图坐标),
                       '揭阳市': GPS坐标类(116.3727, 23.5464, GPS坐标系类型.腾讯地图坐标),
                       '汕尾市': GPS坐标类(115.3757, 22.7863, GPS坐标系类型.腾讯地图坐标),
                       '深圳市': GPS坐标类(114.0573, 22.5430, GPS坐标系类型.腾讯地图坐标),
                       '江门市': GPS坐标类(113.0823, 22.5785, GPS坐标系类型.腾讯地图坐标),
                       '阳江市': GPS坐标类(111.9836, 21.8564, GPS坐标系类型.腾讯地图坐标),
                       '茂名市': GPS坐标类(110.9235, 21.6600, GPS坐标系类型.腾讯地图坐标),
                       '湛江市': GPS坐标类(110.3577, 21.2612, GPS坐标系类型.腾讯地图坐标),
                       '南平市': GPS坐标类(118.1827, 26.6352, GPS坐标系类型.腾讯地图坐标),
                       '宁德市': GPS坐标类(119.5477, 26.6671, GPS坐标系类型.腾讯地图坐标),
                       '三明市': GPS坐标类(117.6389, 26.2639, GPS坐标系类型.腾讯地图坐标),
                       '莆田市': GPS坐标类(119.0067, 25.4557, GPS坐标系类型.腾讯地图坐标),
                       '泉州市': GPS坐标类(118.6743, 24.8715, GPS坐标系类型.腾讯地图坐标),
                       '龙岩市': GPS坐标类(117.0181, 25.0756, GPS坐标系类型.腾讯地图坐标),
                       '厦门市': GPS坐标类(118.0865, 24.4796, GPS坐标系类型.腾讯地图坐标),
                       '漳州市': GPS坐标类(117.6443, 24.5121, GPS坐标系类型.腾讯地图坐标),
                       '新北市': GPS坐标类(121.3715, 25.0035, GPS坐标系类型.高德地图坐标),
                       '桃园市': GPS坐标类(121.1627, 24.9263, GPS坐标系类型.高德地图坐标),
                       '台中市': GPS坐标类(120.6738, 24.1493, GPS坐标系类型.高德地图坐标),
                       '台南市': GPS坐标类(120.1987, 22.9812, GPS坐标系类型.高德地图坐标),
                       '高雄市': GPS坐标类(120.2811, 22.6318, GPS坐标系类型.高德地图坐标),
                       '儋州市': GPS坐标类(109.5804, 19.5184, GPS坐标系类型.腾讯地图坐标),
                       '三亚市': GPS坐标类(109.5117, 18.2528, GPS坐标系类型.腾讯地图坐标),
                       '巴音郭楞蒙古自治州': GPS坐标类(86.1464, 41.7633, GPS坐标系类型.腾讯地图坐标),
                       '锡林郭勒盟': GPS坐标类(116.0530, 43.9279, GPS坐标系类型.腾讯地图坐标),
                       '临夏回族自治州': GPS坐标类(103.2011, 35.5963, GPS坐标系类型.腾讯地图坐标),
                       '甘南藏族自治州': GPS坐标类(102.9117, 34.9833, GPS坐标系类型.腾讯地图坐标),
                       '黄南藏族自治州': GPS坐标类(102.0154, 35.5193, GPS坐标系类型.腾讯地图坐标),
                       '海南藏族自治州': GPS坐标类(100.6227, 36.2965, GPS坐标系类型.腾讯地图坐标),
                       '海北藏族自治州': GPS坐标类(100.9009, 36.9546, GPS坐标系类型.腾讯地图坐标),
                       '海西蒙古族藏族自治州': GPS坐标类(97.3319, 37.3481, GPS坐标系类型.腾讯地图坐标),
                       '果洛藏族自治州': GPS坐标类(100.2372, 34.4757, GPS坐标系类型.腾讯地图坐标),
                       '玉树藏族自治州': GPS坐标类(97.0055, 33.0001, GPS坐标系类型.腾讯地图坐标),
                       '阿拉善盟': GPS坐标类(105.7022, 38.8504, GPS坐标系类型.腾讯地图坐标),
                       '日月潭': GPS坐标类(120.9181, 23.8581, GPS坐标系类型.高德地图坐标),
                       '腾冲市': GPS坐标类(98.4904, 25.0203, GPS坐标系类型.腾讯地图坐标),
                       '墨河市': GPS坐标类(122.5399, 52.9731, GPS坐标系类型.腾讯地图坐标),
                       '黑河市': GPS坐标类(127.5220, 50.2475, GPS坐标系类型.腾讯地图坐标)}

# endregion


class _常用坐标类:
    """
    定义了常用的GPS坐标类对象的集合，您可以通过 常用坐标.帮助文档() 来打印相关的帮助信息
    """

    # region 访问器
    @property
    def 有效(self) -> bool:
        return _常用坐标字典 and isinstance(_常用坐标字典, dict) and len(_常用坐标字典) > 0

    @property
    def 无效(self) -> bool:
        return not self.有效

    @property
    def 常用坐标字典(self) -> dict[str, GPS坐标类]:
        return _常用坐标字典

    @property
    def 数量(self) -> int:
        if self.有效:
            return len(_常用坐标字典)
        else:
            return 0

    # region 城市属性
    # 建议使用 转换字典为属性范式 函数将字典 _常用坐标字典 内容转换为属性成员,以支持IDE成员提示和名称补全
    @property
    def 哈尔滨市(self) -> GPS坐标类:
        if '哈尔滨市' in _常用坐标字典:
            return _常用坐标字典['哈尔滨市']
        else:
            return GPS坐标类()

    @property
    def 长春市(self) -> GPS坐标类:
        if '长春市' in _常用坐标字典:
            return _常用坐标字典['长春市']
        else:
            return GPS坐标类()

    @property
    def 沈阳市(self) -> GPS坐标类:
        if '沈阳市' in _常用坐标字典:
            return _常用坐标字典['沈阳市']
        else:
            return GPS坐标类()

    @property
    def 北京市(self) -> GPS坐标类:
        if '北京市' in _常用坐标字典:
            return _常用坐标字典['北京市']
        else:
            return GPS坐标类()

    @property
    def 呼和浩特市(self) -> GPS坐标类:
        if '呼和浩特市' in _常用坐标字典:
            return _常用坐标字典['呼和浩特市']
        else:
            return GPS坐标类()

    @property
    def 乌鲁木齐市(self) -> GPS坐标类:
        if '乌鲁木齐市' in _常用坐标字典:
            return _常用坐标字典['乌鲁木齐市']
        else:
            return GPS坐标类()

    @property
    def 石家庄市(self) -> GPS坐标类:
        if '石家庄市' in _常用坐标字典:
            return _常用坐标字典['石家庄市']
        else:
            return GPS坐标类()

    @property
    def 天津市(self) -> GPS坐标类:
        if '天津市' in _常用坐标字典:
            return _常用坐标字典['天津市']
        else:
            return GPS坐标类()

    @property
    def 太原市(self) -> GPS坐标类:
        if '太原市' in _常用坐标字典:
            return _常用坐标字典['太原市']
        else:
            return GPS坐标类()

    @property
    def 银川市(self) -> GPS坐标类:
        if '银川市' in _常用坐标字典:
            return _常用坐标字典['银川市']
        else:
            return GPS坐标类()

    @property
    def 济南市(self) -> GPS坐标类:
        if '济南市' in _常用坐标字典:
            return _常用坐标字典['济南市']
        else:
            return GPS坐标类()

    @property
    def 西宁市(self) -> GPS坐标类:
        if '西宁市' in _常用坐标字典:
            return _常用坐标字典['西宁市']
        else:
            return GPS坐标类()

    @property
    def 兰州市(self) -> GPS坐标类:
        if '兰州市' in _常用坐标字典:
            return _常用坐标字典['兰州市']
        else:
            return GPS坐标类()

    @property
    def 郑州市(self) -> GPS坐标类:
        if '郑州市' in _常用坐标字典:
            return _常用坐标字典['郑州市']
        else:
            return GPS坐标类()

    @property
    def 西安市(self) -> GPS坐标类:
        if '西安市' in _常用坐标字典:
            return _常用坐标字典['西安市']
        else:
            return GPS坐标类()

    @property
    def 南京市(self) -> GPS坐标类:
        if '南京市' in _常用坐标字典:
            return _常用坐标字典['南京市']
        else:
            return GPS坐标类()

    @property
    def 合肥市(self) -> GPS坐标类:
        if '合肥市' in _常用坐标字典:
            return _常用坐标字典['合肥市']
        else:
            return GPS坐标类()

    @property
    def 上海市(self) -> GPS坐标类:
        if '上海市' in _常用坐标字典:
            return _常用坐标字典['上海市']
        else:
            return GPS坐标类()

    @property
    def 武汉市(self) -> GPS坐标类:
        if '武汉市' in _常用坐标字典:
            return _常用坐标字典['武汉市']
        else:
            return GPS坐标类()

    @property
    def 成都市(self) -> GPS坐标类:
        if '成都市' in _常用坐标字典:
            return _常用坐标字典['成都市']
        else:
            return GPS坐标类()

    @property
    def 杭州市(self) -> GPS坐标类:
        if '杭州市' in _常用坐标字典:
            return _常用坐标字典['杭州市']
        else:
            return GPS坐标类()

    @property
    def 重庆市(self) -> GPS坐标类:
        if '重庆市' in _常用坐标字典:
            return _常用坐标字典['重庆市']
        else:
            return GPS坐标类()

    @property
    def 拉萨市(self) -> GPS坐标类:
        if '拉萨市' in _常用坐标字典:
            return _常用坐标字典['拉萨市']
        else:
            return GPS坐标类()

    @property
    def 南昌市(self) -> GPS坐标类:
        if '南昌市' in _常用坐标字典:
            return _常用坐标字典['南昌市']
        else:
            return GPS坐标类()

    @property
    def 长沙市(self) -> GPS坐标类:
        if '长沙市' in _常用坐标字典:
            return _常用坐标字典['长沙市']
        else:
            return GPS坐标类()

    @property
    def 贵阳市(self) -> GPS坐标类:
        if '贵阳市' in _常用坐标字典:
            return _常用坐标字典['贵阳市']
        else:
            return GPS坐标类()

    @property
    def 昆明市(self) -> GPS坐标类:
        if '昆明市' in _常用坐标字典:
            return _常用坐标字典['昆明市']
        else:
            return GPS坐标类()

    @property
    def 福州市(self) -> GPS坐标类:
        if '福州市' in _常用坐标字典:
            return _常用坐标字典['福州市']
        else:
            return GPS坐标类()

    @property
    def 台北市(self) -> GPS坐标类:
        if '台北市' in _常用坐标字典:
            return _常用坐标字典['台北市']
        else:
            return GPS坐标类()

    @property
    def 广州市(self) -> GPS坐标类:
        if '广州市' in _常用坐标字典:
            return _常用坐标字典['广州市']
        else:
            return GPS坐标类()

    @property
    def 南宁市(self) -> GPS坐标类:
        if '南宁市' in _常用坐标字典:
            return _常用坐标字典['南宁市']
        else:
            return GPS坐标类()

    @property
    def 澳门特别行政区(self) -> GPS坐标类:
        if '澳门特别行政区' in _常用坐标字典:
            return _常用坐标字典['澳门特别行政区']
        else:
            return GPS坐标类()

    @property
    def 香港特别行政区(self) -> GPS坐标类:
        if '香港特别行政区' in _常用坐标字典:
            return _常用坐标字典['香港特别行政区']
        else:
            return GPS坐标类()

    @property
    def 海口市(self) -> GPS坐标类:
        if '海口市' in _常用坐标字典:
            return _常用坐标字典['海口市']
        else:
            return GPS坐标类()

    @property
    def 曾母暗沙(self) -> GPS坐标类:
        if '曾母暗沙' in _常用坐标字典:
            return _常用坐标字典['曾母暗沙']
        else:
            return GPS坐标类()

    @property
    def 南沙群岛(self) -> GPS坐标类:
        if '南沙群岛' in _常用坐标字典:
            return _常用坐标字典['南沙群岛']
        else:
            return GPS坐标类()

    @property
    def 黄岩岛(self) -> GPS坐标类:
        if '黄岩岛' in _常用坐标字典:
            return _常用坐标字典['黄岩岛']
        else:
            return GPS坐标类()

    @property
    def 三沙市(self) -> GPS坐标类:
        if '三沙市' in _常用坐标字典:
            return _常用坐标字典['三沙市']
        else:
            return GPS坐标类()

    @property
    def 钓鱼岛(self) -> GPS坐标类:
        if '钓鱼岛' in _常用坐标字典:
            return _常用坐标字典['钓鱼岛']
        else:
            return GPS坐标类()

    @property
    def 赤尾屿(self) -> GPS坐标类:
        if '赤尾屿' in _常用坐标字典:
            return _常用坐标字典['赤尾屿']
        else:
            return GPS坐标类()

    @property
    def 黑瞎子岛(self) -> GPS坐标类:
        if '黑瞎子岛' in _常用坐标字典:
            return _常用坐标字典['黑瞎子岛']
        else:
            return GPS坐标类()

    @property
    def 伊春市(self) -> GPS坐标类:
        if '伊春市' in _常用坐标字典:
            return _常用坐标字典['伊春市']
        else:
            return GPS坐标类()

    @property
    def 鹤岗市(self) -> GPS坐标类:
        if '鹤岗市' in _常用坐标字典:
            return _常用坐标字典['鹤岗市']
        else:
            return GPS坐标类()

    @property
    def 佳木斯市(self) -> GPS坐标类:
        if '佳木斯市' in _常用坐标字典:
            return _常用坐标字典['佳木斯市']
        else:
            return GPS坐标类()

    @property
    def 双鸭山市(self) -> GPS坐标类:
        if '双鸭山市' in _常用坐标字典:
            return _常用坐标字典['双鸭山市']
        else:
            return GPS坐标类()

    @property
    def 七台河市(self) -> GPS坐标类:
        if '七台河市' in _常用坐标字典:
            return _常用坐标字典['七台河市']
        else:
            return GPS坐标类()

    @property
    def 鸡西市(self) -> GPS坐标类:
        if '鸡西市' in _常用坐标字典:
            return _常用坐标字典['鸡西市']
        else:
            return GPS坐标类()

    @property
    def 牡丹江市(self) -> GPS坐标类:
        if '牡丹江市' in _常用坐标字典:
            return _常用坐标字典['牡丹江市']
        else:
            return GPS坐标类()

    @property
    def 绥化市(self) -> GPS坐标类:
        if '绥化市' in _常用坐标字典:
            return _常用坐标字典['绥化市']
        else:
            return GPS坐标类()

    @property
    def 大庆市(self) -> GPS坐标类:
        if '大庆市' in _常用坐标字典:
            return _常用坐标字典['大庆市']
        else:
            return GPS坐标类()

    @property
    def 齐齐哈尔市(self) -> GPS坐标类:
        if '齐齐哈尔市' in _常用坐标字典:
            return _常用坐标字典['齐齐哈尔市']
        else:
            return GPS坐标类()

    @property
    def 白城市(self) -> GPS坐标类:
        if '白城市' in _常用坐标字典:
            return _常用坐标字典['白城市']
        else:
            return GPS坐标类()

    @property
    def 松原市(self) -> GPS坐标类:
        if '松原市' in _常用坐标字典:
            return _常用坐标字典['松原市']
        else:
            return GPS坐标类()

    @property
    def 吉林市(self) -> GPS坐标类:
        if '吉林市' in _常用坐标字典:
            return _常用坐标字典['吉林市']
        else:
            return GPS坐标类()

    @property
    def 延边朝鲜族自治州(self) -> GPS坐标类:
        if '延边朝鲜族自治州' in _常用坐标字典:
            return _常用坐标字典['延边朝鲜族自治州']
        else:
            return GPS坐标类()

    @property
    def 辽源市(self) -> GPS坐标类:
        if '辽源市' in _常用坐标字典:
            return _常用坐标字典['辽源市']
        else:
            return GPS坐标类()

    @property
    def 四平市(self) -> GPS坐标类:
        if '四平市' in _常用坐标字典:
            return _常用坐标字典['四平市']
        else:
            return GPS坐标类()

    @property
    def 白山市(self) -> GPS坐标类:
        if '白山市' in _常用坐标字典:
            return _常用坐标字典['白山市']
        else:
            return GPS坐标类()

    @property
    def 通化市(self) -> GPS坐标类:
        if '通化市' in _常用坐标字典:
            return _常用坐标字典['通化市']
        else:
            return GPS坐标类()

    @property
    def 铁岭市(self) -> GPS坐标类:
        if '铁岭市' in _常用坐标字典:
            return _常用坐标字典['铁岭市']
        else:
            return GPS坐标类()

    @property
    def 抚顺市(self) -> GPS坐标类:
        if '抚顺市' in _常用坐标字典:
            return _常用坐标字典['抚顺市']
        else:
            return GPS坐标类()

    @property
    def 本溪市(self) -> GPS坐标类:
        if '本溪市' in _常用坐标字典:
            return _常用坐标字典['本溪市']
        else:
            return GPS坐标类()

    @property
    def 辽阳市(self) -> GPS坐标类:
        if '辽阳市' in _常用坐标字典:
            return _常用坐标字典['辽阳市']
        else:
            return GPS坐标类()

    @property
    def 鞍山市(self) -> GPS坐标类:
        if '鞍山市' in _常用坐标字典:
            return _常用坐标字典['鞍山市']
        else:
            return GPS坐标类()

    @property
    def 盘锦市(self) -> GPS坐标类:
        if '盘锦市' in _常用坐标字典:
            return _常用坐标字典['盘锦市']
        else:
            return GPS坐标类()

    @property
    def 营口市(self) -> GPS坐标类:
        if '营口市' in _常用坐标字典:
            return _常用坐标字典['营口市']
        else:
            return GPS坐标类()

    @property
    def 阜新市(self) -> GPS坐标类:
        if '阜新市' in _常用坐标字典:
            return _常用坐标字典['阜新市']
        else:
            return GPS坐标类()

    @property
    def 朝阳市(self) -> GPS坐标类:
        if '朝阳市' in _常用坐标字典:
            return _常用坐标字典['朝阳市']
        else:
            return GPS坐标类()

    @property
    def 锦州市(self) -> GPS坐标类:
        if '锦州市' in _常用坐标字典:
            return _常用坐标字典['锦州市']
        else:
            return GPS坐标类()

    @property
    def 葫芦岛市(self) -> GPS坐标类:
        if '葫芦岛市' in _常用坐标字典:
            return _常用坐标字典['葫芦岛市']
        else:
            return GPS坐标类()

    @property
    def 大连市(self) -> GPS坐标类:
        if '大连市' in _常用坐标字典:
            return _常用坐标字典['大连市']
        else:
            return GPS坐标类()

    @property
    def 秦皇岛市(self) -> GPS坐标类:
        if '秦皇岛市' in _常用坐标字典:
            return _常用坐标字典['秦皇岛市']
        else:
            return GPS坐标类()

    @property
    def 承德市(self) -> GPS坐标类:
        if '承德市' in _常用坐标字典:
            return _常用坐标字典['承德市']
        else:
            return GPS坐标类()

    @property
    def 唐山市(self) -> GPS坐标类:
        if '唐山市' in _常用坐标字典:
            return _常用坐标字典['唐山市']
        else:
            return GPS坐标类()

    @property
    def 张家口市(self) -> GPS坐标类:
        if '张家口市' in _常用坐标字典:
            return _常用坐标字典['张家口市']
        else:
            return GPS坐标类()

    @property
    def 雄安新区(self) -> GPS坐标类:
        if '雄安新区' in _常用坐标字典:
            return _常用坐标字典['雄安新区']
        else:
            return GPS坐标类()

    @property
    def 保定市(self) -> GPS坐标类:
        if '保定市' in _常用坐标字典:
            return _常用坐标字典['保定市']
        else:
            return GPS坐标类()

    @property
    def 沧州市(self) -> GPS坐标类:
        if '沧州市' in _常用坐标字典:
            return _常用坐标字典['沧州市']
        else:
            return GPS坐标类()

    @property
    def 衡水市(self) -> GPS坐标类:
        if '衡水市' in _常用坐标字典:
            return _常用坐标字典['衡水市']
        else:
            return GPS坐标类()

    @property
    def 邢台市(self) -> GPS坐标类:
        if '邢台市' in _常用坐标字典:
            return _常用坐标字典['邢台市']
        else:
            return GPS坐标类()

    @property
    def 邯郸市(self) -> GPS坐标类:
        if '邯郸市' in _常用坐标字典:
            return _常用坐标字典['邯郸市']
        else:
            return GPS坐标类()

    @property
    def 大同市(self) -> GPS坐标类:
        if '大同市' in _常用坐标字典:
            return _常用坐标字典['大同市']
        else:
            return GPS坐标类()

    @property
    def 朔州市(self) -> GPS坐标类:
        if '朔州市' in _常用坐标字典:
            return _常用坐标字典['朔州市']
        else:
            return GPS坐标类()

    @property
    def 忻州市(self) -> GPS坐标类:
        if '忻州市' in _常用坐标字典:
            return _常用坐标字典['忻州市']
        else:
            return GPS坐标类()

    @property
    def 阳泉市(self) -> GPS坐标类:
        if '阳泉市' in _常用坐标字典:
            return _常用坐标字典['阳泉市']
        else:
            return GPS坐标类()

    @property
    def 晋中市(self) -> GPS坐标类:
        if '晋中市' in _常用坐标字典:
            return _常用坐标字典['晋中市']
        else:
            return GPS坐标类()

    @property
    def 吕梁市(self) -> GPS坐标类:
        if '吕梁市' in _常用坐标字典:
            return _常用坐标字典['吕梁市']
        else:
            return GPS坐标类()

    @property
    def 临汾市(self) -> GPS坐标类:
        if '临汾市' in _常用坐标字典:
            return _常用坐标字典['临汾市']
        else:
            return GPS坐标类()

    @property
    def 长治市(self) -> GPS坐标类:
        if '长治市' in _常用坐标字典:
            return _常用坐标字典['长治市']
        else:
            return GPS坐标类()

    @property
    def 晋城市(self) -> GPS坐标类:
        if '晋城市' in _常用坐标字典:
            return _常用坐标字典['晋城市']
        else:
            return GPS坐标类()

    @property
    def 运城市(self) -> GPS坐标类:
        if '运城市' in _常用坐标字典:
            return _常用坐标字典['运城市']
        else:
            return GPS坐标类()

    @property
    def 榆林市(self) -> GPS坐标类:
        if '榆林市' in _常用坐标字典:
            return _常用坐标字典['榆林市']
        else:
            return GPS坐标类()

    @property
    def 延安市(self) -> GPS坐标类:
        if '延安市' in _常用坐标字典:
            return _常用坐标字典['延安市']
        else:
            return GPS坐标类()

    @property
    def 铜川市(self) -> GPS坐标类:
        if '铜川市' in _常用坐标字典:
            return _常用坐标字典['铜川市']
        else:
            return GPS坐标类()

    @property
    def 渭南市(self) -> GPS坐标类:
        if '渭南市' in _常用坐标字典:
            return _常用坐标字典['渭南市']
        else:
            return GPS坐标类()

    @property
    def 咸阳市(self) -> GPS坐标类:
        if '咸阳市' in _常用坐标字典:
            return _常用坐标字典['咸阳市']
        else:
            return GPS坐标类()

    @property
    def 商洛市(self) -> GPS坐标类:
        if '商洛市' in _常用坐标字典:
            return _常用坐标字典['商洛市']
        else:
            return GPS坐标类()

    @property
    def 安康市(self) -> GPS坐标类:
        if '安康市' in _常用坐标字典:
            return _常用坐标字典['安康市']
        else:
            return GPS坐标类()

    @property
    def 汉中市(self) -> GPS坐标类:
        if '汉中市' in _常用坐标字典:
            return _常用坐标字典['汉中市']
        else:
            return GPS坐标类()

    @property
    def 宝鸡市(self) -> GPS坐标类:
        if '宝鸡市' in _常用坐标字典:
            return _常用坐标字典['宝鸡市']
        else:
            return GPS坐标类()

    @property
    def 石嘴山市(self) -> GPS坐标类:
        if '石嘴山市' in _常用坐标字典:
            return _常用坐标字典['石嘴山市']
        else:
            return GPS坐标类()

    @property
    def 吴忠市(self) -> GPS坐标类:
        if '吴忠市' in _常用坐标字典:
            return _常用坐标字典['吴忠市']
        else:
            return GPS坐标类()

    @property
    def 中卫市(self) -> GPS坐标类:
        if '中卫市' in _常用坐标字典:
            return _常用坐标字典['中卫市']
        else:
            return GPS坐标类()

    @property
    def 固原市(self) -> GPS坐标类:
        if '固原市' in _常用坐标字典:
            return _常用坐标字典['固原市']
        else:
            return GPS坐标类()

    @property
    def 庆阳市(self) -> GPS坐标类:
        if '庆阳市' in _常用坐标字典:
            return _常用坐标字典['庆阳市']
        else:
            return GPS坐标类()

    @property
    def 平凉市(self) -> GPS坐标类:
        if '平凉市' in _常用坐标字典:
            return _常用坐标字典['平凉市']
        else:
            return GPS坐标类()

    @property
    def 天水市(self) -> GPS坐标类:
        if '天水市' in _常用坐标字典:
            return _常用坐标字典['天水市']
        else:
            return GPS坐标类()

    @property
    def 陇南市(self) -> GPS坐标类:
        if '陇南市' in _常用坐标字典:
            return _常用坐标字典['陇南市']
        else:
            return GPS坐标类()

    @property
    def 定西市(self) -> GPS坐标类:
        if '定西市' in _常用坐标字典:
            return _常用坐标字典['定西市']
        else:
            return GPS坐标类()

    @property
    def 白银市(self) -> GPS坐标类:
        if '白银市' in _常用坐标字典:
            return _常用坐标字典['白银市']
        else:
            return GPS坐标类()

    @property
    def 海东市(self) -> GPS坐标类:
        if '海东市' in _常用坐标字典:
            return _常用坐标字典['海东市']
        else:
            return GPS坐标类()

    @property
    def 武威市(self) -> GPS坐标类:
        if '武威市' in _常用坐标字典:
            return _常用坐标字典['武威市']
        else:
            return GPS坐标类()

    @property
    def 金昌市(self) -> GPS坐标类:
        if '金昌市' in _常用坐标字典:
            return _常用坐标字典['金昌市']
        else:
            return GPS坐标类()

    @property
    def 张掖市(self) -> GPS坐标类:
        if '张掖市' in _常用坐标字典:
            return _常用坐标字典['张掖市']
        else:
            return GPS坐标类()

    @property
    def 酒泉市(self) -> GPS坐标类:
        if '酒泉市' in _常用坐标字典:
            return _常用坐标字典['酒泉市']
        else:
            return GPS坐标类()

    @property
    def 嘉峪关市(self) -> GPS坐标类:
        if '嘉峪关市' in _常用坐标字典:
            return _常用坐标字典['嘉峪关市']
        else:
            return GPS坐标类()

    @property
    def 哈密市(self) -> GPS坐标类:
        if '哈密市' in _常用坐标字典:
            return _常用坐标字典['哈密市']
        else:
            return GPS坐标类()

    @property
    def 新星市(self) -> GPS坐标类:
        if '新星市' in _常用坐标字典:
            return _常用坐标字典['新星市']
        else:
            return GPS坐标类()

    @property
    def 吐鲁番市(self) -> GPS坐标类:
        if '吐鲁番市' in _常用坐标字典:
            return _常用坐标字典['吐鲁番市']
        else:
            return GPS坐标类()

    @property
    def 胡杨河市(self) -> GPS坐标类:
        if '胡杨河市' in _常用坐标字典:
            return _常用坐标字典['胡杨河市']
        else:
            return GPS坐标类()

    @property
    def 克拉玛依市(self) -> GPS坐标类:
        if '克拉玛依市' in _常用坐标字典:
            return _常用坐标字典['克拉玛依市']
        else:
            return GPS坐标类()

    @property
    def 阿勒泰地区(self) -> GPS坐标类:
        if '阿勒泰地区' in _常用坐标字典:
            return _常用坐标字典['阿勒泰地区']
        else:
            return GPS坐标类()

    @property
    def 博尔塔拉蒙古自治州(self) -> GPS坐标类:
        if '博尔塔拉蒙古自治州' in _常用坐标字典:
            return _常用坐标字典['博尔塔拉蒙古自治州']
        else:
            return GPS坐标类()

    @property
    def 伊犁哈萨克自治州(self) -> GPS坐标类:
        if '伊犁哈萨克自治州' in _常用坐标字典:
            return _常用坐标字典['伊犁哈萨克自治州']
        else:
            return GPS坐标类()

    @property
    def 阿克苏地区(self) -> GPS坐标类:
        if '阿克苏地区' in _常用坐标字典:
            return _常用坐标字典['阿克苏地区']
        else:
            return GPS坐标类()

    @property
    def 客什地区(self) -> GPS坐标类:
        if '客什地区' in _常用坐标字典:
            return _常用坐标字典['客什地区']
        else:
            return GPS坐标类()

    @property
    def 和田地区(self) -> GPS坐标类:
        if '和田地区' in _常用坐标字典:
            return _常用坐标字典['和田地区']
        else:
            return GPS坐标类()

    @property
    def 大兴安岭地区(self) -> GPS坐标类:
        if '大兴安岭地区' in _常用坐标字典:
            return _常用坐标字典['大兴安岭地区']
        else:
            return GPS坐标类()

    @property
    def 呼伦贝尔市(self) -> GPS坐标类:
        if '呼伦贝尔市' in _常用坐标字典:
            return _常用坐标字典['呼伦贝尔市']
        else:
            return GPS坐标类()

    @property
    def 通辽市(self) -> GPS坐标类:
        if '通辽市' in _常用坐标字典:
            return _常用坐标字典['通辽市']
        else:
            return GPS坐标类()

    @property
    def 赤峰市(self) -> GPS坐标类:
        if '赤峰市' in _常用坐标字典:
            return _常用坐标字典['赤峰市']
        else:
            return GPS坐标类()

    @property
    def 乌兰察布市(self) -> GPS坐标类:
        if '乌兰察布市' in _常用坐标字典:
            return _常用坐标字典['乌兰察布市']
        else:
            return GPS坐标类()

    @property
    def 包头市(self) -> GPS坐标类:
        if '包头市' in _常用坐标字典:
            return _常用坐标字典['包头市']
        else:
            return GPS坐标类()

    @property
    def 鄂尔多斯市(self) -> GPS坐标类:
        if '鄂尔多斯市' in _常用坐标字典:
            return _常用坐标字典['鄂尔多斯市']
        else:
            return GPS坐标类()

    @property
    def 巴彦淖尔市(self) -> GPS坐标类:
        if '巴彦淖尔市' in _常用坐标字典:
            return _常用坐标字典['巴彦淖尔市']
        else:
            return GPS坐标类()

    @property
    def 乌海市(self) -> GPS坐标类:
        if '乌海市' in _常用坐标字典:
            return _常用坐标字典['乌海市']
        else:
            return GPS坐标类()

    @property
    def 阿里地区(self) -> GPS坐标类:
        if '阿里地区' in _常用坐标字典:
            return _常用坐标字典['阿里地区']
        else:
            return GPS坐标类()

    @property
    def 日客则市(self) -> GPS坐标类:
        if '日客则市' in _常用坐标字典:
            return _常用坐标字典['日客则市']
        else:
            return GPS坐标类()

    @property
    def 山南市(self) -> GPS坐标类:
        if '山南市' in _常用坐标字典:
            return _常用坐标字典['山南市']
        else:
            return GPS坐标类()

    @property
    def 林芝市(self) -> GPS坐标类:
        if '林芝市' in _常用坐标字典:
            return _常用坐标字典['林芝市']
        else:
            return GPS坐标类()

    @property
    def 那曲市(self) -> GPS坐标类:
        if '那曲市' in _常用坐标字典:
            return _常用坐标字典['那曲市']
        else:
            return GPS坐标类()

    @property
    def 昌都市(self) -> GPS坐标类:
        if '昌都市' in _常用坐标字典:
            return _常用坐标字典['昌都市']
        else:
            return GPS坐标类()

    @property
    def 珠穆拉玛峰(self) -> GPS坐标类:
        if '珠穆拉玛峰' in _常用坐标字典:
            return _常用坐标字典['珠穆拉玛峰']
        else:
            return GPS坐标类()

    @property
    def 安阳市(self) -> GPS坐标类:
        if '安阳市' in _常用坐标字典:
            return _常用坐标字典['安阳市']
        else:
            return GPS坐标类()

    @property
    def 鹤壁市(self) -> GPS坐标类:
        if '鹤壁市' in _常用坐标字典:
            return _常用坐标字典['鹤壁市']
        else:
            return GPS坐标类()

    @property
    def 焦作市(self) -> GPS坐标类:
        if '焦作市' in _常用坐标字典:
            return _常用坐标字典['焦作市']
        else:
            return GPS坐标类()

    @property
    def 三门峡市(self) -> GPS坐标类:
        if '三门峡市' in _常用坐标字典:
            return _常用坐标字典['三门峡市']
        else:
            return GPS坐标类()

    @property
    def 濮阳市(self) -> GPS坐标类:
        if '濮阳市' in _常用坐标字典:
            return _常用坐标字典['濮阳市']
        else:
            return GPS坐标类()

    @property
    def 新乡市(self) -> GPS坐标类:
        if '新乡市' in _常用坐标字典:
            return _常用坐标字典['新乡市']
        else:
            return GPS坐标类()

    @property
    def 开封市(self) -> GPS坐标类:
        if '开封市' in _常用坐标字典:
            return _常用坐标字典['开封市']
        else:
            return GPS坐标类()

    @property
    def 洛阳市(self) -> GPS坐标类:
        if '洛阳市' in _常用坐标字典:
            return _常用坐标字典['洛阳市']
        else:
            return GPS坐标类()

    @property
    def 商丘市(self) -> GPS坐标类:
        if '商丘市' in _常用坐标字典:
            return _常用坐标字典['商丘市']
        else:
            return GPS坐标类()

    @property
    def 许昌市(self) -> GPS坐标类:
        if '许昌市' in _常用坐标字典:
            return _常用坐标字典['许昌市']
        else:
            return GPS坐标类()

    @property
    def 平顶山市(self) -> GPS坐标类:
        if '平顶山市' in _常用坐标字典:
            return _常用坐标字典['平顶山市']
        else:
            return GPS坐标类()

    @property
    def 周口市(self) -> GPS坐标类:
        if '周口市' in _常用坐标字典:
            return _常用坐标字典['周口市']
        else:
            return GPS坐标类()

    @property
    def 漯河市(self) -> GPS坐标类:
        if '漯河市' in _常用坐标字典:
            return _常用坐标字典['漯河市']
        else:
            return GPS坐标类()

    @property
    def 南阳市(self) -> GPS坐标类:
        if '南阳市' in _常用坐标字典:
            return _常用坐标字典['南阳市']
        else:
            return GPS坐标类()

    @property
    def 驻马店市(self) -> GPS坐标类:
        if '驻马店市' in _常用坐标字典:
            return _常用坐标字典['驻马店市']
        else:
            return GPS坐标类()

    @property
    def 信阳市(self) -> GPS坐标类:
        if '信阳市' in _常用坐标字典:
            return _常用坐标字典['信阳市']
        else:
            return GPS坐标类()

    @property
    def 德州市(self) -> GPS坐标类:
        if '德州市' in _常用坐标字典:
            return _常用坐标字典['德州市']
        else:
            return GPS坐标类()

    @property
    def 滨州市(self) -> GPS坐标类:
        if '滨州市' in _常用坐标字典:
            return _常用坐标字典['滨州市']
        else:
            return GPS坐标类()

    @property
    def 东营市(self) -> GPS坐标类:
        if '东营市' in _常用坐标字典:
            return _常用坐标字典['东营市']
        else:
            return GPS坐标类()

    @property
    def 烟台市(self) -> GPS坐标类:
        if '烟台市' in _常用坐标字典:
            return _常用坐标字典['烟台市']
        else:
            return GPS坐标类()

    @property
    def 威海市(self) -> GPS坐标类:
        if '威海市' in _常用坐标字典:
            return _常用坐标字典['威海市']
        else:
            return GPS坐标类()

    @property
    def 潍坊市(self) -> GPS坐标类:
        if '潍坊市' in _常用坐标字典:
            return _常用坐标字典['潍坊市']
        else:
            return GPS坐标类()

    @property
    def 淄博市(self) -> GPS坐标类:
        if '淄博市' in _常用坐标字典:
            return _常用坐标字典['淄博市']
        else:
            return GPS坐标类()

    @property
    def 聊城市(self) -> GPS坐标类:
        if '聊城市' in _常用坐标字典:
            return _常用坐标字典['聊城市']
        else:
            return GPS坐标类()

    @property
    def 泰安市(self) -> GPS坐标类:
        if '泰安市' in _常用坐标字典:
            return _常用坐标字典['泰安市']
        else:
            return GPS坐标类()

    @property
    def 青岛市(self) -> GPS坐标类:
        if '青岛市' in _常用坐标字典:
            return _常用坐标字典['青岛市']
        else:
            return GPS坐标类()

    @property
    def 菏泽市(self) -> GPS坐标类:
        if '菏泽市' in _常用坐标字典:
            return _常用坐标字典['菏泽市']
        else:
            return GPS坐标类()

    @property
    def 济宁市(self) -> GPS坐标类:
        if '济宁市' in _常用坐标字典:
            return _常用坐标字典['济宁市']
        else:
            return GPS坐标类()

    @property
    def 日照市(self) -> GPS坐标类:
        if '日照市' in _常用坐标字典:
            return _常用坐标字典['日照市']
        else:
            return GPS坐标类()

    @property
    def 临沂市(self) -> GPS坐标类:
        if '临沂市' in _常用坐标字典:
            return _常用坐标字典['临沂市']
        else:
            return GPS坐标类()

    @property
    def 枣庄市(self) -> GPS坐标类:
        if '枣庄市' in _常用坐标字典:
            return _常用坐标字典['枣庄市']
        else:
            return GPS坐标类()

    @property
    def 连云港市(self) -> GPS坐标类:
        if '连云港市' in _常用坐标字典:
            return _常用坐标字典['连云港市']
        else:
            return GPS坐标类()

    @property
    def 徐州市(self) -> GPS坐标类:
        if '徐州市' in _常用坐标字典:
            return _常用坐标字典['徐州市']
        else:
            return GPS坐标类()

    @property
    def 宿迁市(self) -> GPS坐标类:
        if '宿迁市' in _常用坐标字典:
            return _常用坐标字典['宿迁市']
        else:
            return GPS坐标类()

    @property
    def 淮安市(self) -> GPS坐标类:
        if '淮安市' in _常用坐标字典:
            return _常用坐标字典['淮安市']
        else:
            return GPS坐标类()

    @property
    def 盐城市(self) -> GPS坐标类:
        if '盐城市' in _常用坐标字典:
            return _常用坐标字典['盐城市']
        else:
            return GPS坐标类()

    @property
    def 泰州市(self) -> GPS坐标类:
        if '泰州市' in _常用坐标字典:
            return _常用坐标字典['泰州市']
        else:
            return GPS坐标类()

    @property
    def 杨州市(self) -> GPS坐标类:
        if '杨州市' in _常用坐标字典:
            return _常用坐标字典['杨州市']
        else:
            return GPS坐标类()

    @property
    def 镇江市(self) -> GPS坐标类:
        if '镇江市' in _常用坐标字典:
            return _常用坐标字典['镇江市']
        else:
            return GPS坐标类()

    @property
    def 南通市(self) -> GPS坐标类:
        if '南通市' in _常用坐标字典:
            return _常用坐标字典['南通市']
        else:
            return GPS坐标类()

    @property
    def 常州市(self) -> GPS坐标类:
        if '常州市' in _常用坐标字典:
            return _常用坐标字典['常州市']
        else:
            return GPS坐标类()

    @property
    def 苏州市(self) -> GPS坐标类:
        if '苏州市' in _常用坐标字典:
            return _常用坐标字典['苏州市']
        else:
            return GPS坐标类()

    @property
    def 无锡市(self) -> GPS坐标类:
        if '无锡市' in _常用坐标字典:
            return _常用坐标字典['无锡市']
        else:
            return GPS坐标类()

    @property
    def 太湖(self) -> GPS坐标类:
        if '太湖' in _常用坐标字典:
            return _常用坐标字典['太湖']
        else:
            return GPS坐标类()

    @property
    def 昆山市(self) -> GPS坐标类:
        if '昆山市' in _常用坐标字典:
            return _常用坐标字典['昆山市']
        else:
            return GPS坐标类()

    @property
    def 淮北市(self) -> GPS坐标类:
        if '淮北市' in _常用坐标字典:
            return _常用坐标字典['淮北市']
        else:
            return GPS坐标类()

    @property
    def 亳州市(self) -> GPS坐标类:
        if '亳州市' in _常用坐标字典:
            return _常用坐标字典['亳州市']
        else:
            return GPS坐标类()

    @property
    def 阜阳市(self) -> GPS坐标类:
        if '阜阳市' in _常用坐标字典:
            return _常用坐标字典['阜阳市']
        else:
            return GPS坐标类()

    @property
    def 蚌埠市(self) -> GPS坐标类:
        if '蚌埠市' in _常用坐标字典:
            return _常用坐标字典['蚌埠市']
        else:
            return GPS坐标类()

    @property
    def 淮南市(self) -> GPS坐标类:
        if '淮南市' in _常用坐标字典:
            return _常用坐标字典['淮南市']
        else:
            return GPS坐标类()

    @property
    def 六安市(self) -> GPS坐标类:
        if '六安市' in _常用坐标字典:
            return _常用坐标字典['六安市']
        else:
            return GPS坐标类()

    @property
    def 滁州市(self) -> GPS坐标类:
        if '滁州市' in _常用坐标字典:
            return _常用坐标字典['滁州市']
        else:
            return GPS坐标类()

    @property
    def 马鞍山市(self) -> GPS坐标类:
        if '马鞍山市' in _常用坐标字典:
            return _常用坐标字典['马鞍山市']
        else:
            return GPS坐标类()

    @property
    def 芜湖市(self) -> GPS坐标类:
        if '芜湖市' in _常用坐标字典:
            return _常用坐标字典['芜湖市']
        else:
            return GPS坐标类()

    @property
    def 宣城市(self) -> GPS坐标类:
        if '宣城市' in _常用坐标字典:
            return _常用坐标字典['宣城市']
        else:
            return GPS坐标类()

    @property
    def 铜陵市(self) -> GPS坐标类:
        if '铜陵市' in _常用坐标字典:
            return _常用坐标字典['铜陵市']
        else:
            return GPS坐标类()

    @property
    def 池州市(self) -> GPS坐标类:
        if '池州市' in _常用坐标字典:
            return _常用坐标字典['池州市']
        else:
            return GPS坐标类()

    @property
    def 安庆市(self) -> GPS坐标类:
        if '安庆市' in _常用坐标字典:
            return _常用坐标字典['安庆市']
        else:
            return GPS坐标类()

    @property
    def 黄山市(self) -> GPS坐标类:
        if '黄山市' in _常用坐标字典:
            return _常用坐标字典['黄山市']
        else:
            return GPS坐标类()

    @property
    def 黄山风景区(self) -> GPS坐标类:
        if '黄山风景区' in _常用坐标字典:
            return _常用坐标字典['黄山风景区']
        else:
            return GPS坐标类()

    @property
    def 鄂州市(self) -> GPS坐标类:
        if '鄂州市' in _常用坐标字典:
            return _常用坐标字典['鄂州市']
        else:
            return GPS坐标类()

    @property
    def 咸宁市(self) -> GPS坐标类:
        if '咸宁市' in _常用坐标字典:
            return _常用坐标字典['咸宁市']
        else:
            return GPS坐标类()

    @property
    def 孝感市(self) -> GPS坐标类:
        if '孝感市' in _常用坐标字典:
            return _常用坐标字典['孝感市']
        else:
            return GPS坐标类()

    @property
    def 随州市(self) -> GPS坐标类:
        if '随州市' in _常用坐标字典:
            return _常用坐标字典['随州市']
        else:
            return GPS坐标类()

    @property
    def 荆门市(self) -> GPS坐标类:
        if '荆门市' in _常用坐标字典:
            return _常用坐标字典['荆门市']
        else:
            return GPS坐标类()

    @property
    def 荆州市(self) -> GPS坐标类:
        if '荆州市' in _常用坐标字典:
            return _常用坐标字典['荆州市']
        else:
            return GPS坐标类()

    @property
    def 襄阳市(self) -> GPS坐标类:
        if '襄阳市' in _常用坐标字典:
            return _常用坐标字典['襄阳市']
        else:
            return GPS坐标类()

    @property
    def 宜昌市(self) -> GPS坐标类:
        if '宜昌市' in _常用坐标字典:
            return _常用坐标字典['宜昌市']
        else:
            return GPS坐标类()

    @property
    def 十堰市(self) -> GPS坐标类:
        if '十堰市' in _常用坐标字典:
            return _常用坐标字典['十堰市']
        else:
            return GPS坐标类()

    @property
    def 恩施土家族苗族自治州(self) -> GPS坐标类:
        if '恩施土家族苗族自治州' in _常用坐标字典:
            return _常用坐标字典['恩施土家族苗族自治州']
        else:
            return GPS坐标类()

    @property
    def 黄石市(self) -> GPS坐标类:
        if '黄石市' in _常用坐标字典:
            return _常用坐标字典['黄石市']
        else:
            return GPS坐标类()

    @property
    def 黄冈市(self) -> GPS坐标类:
        if '黄冈市' in _常用坐标字典:
            return _常用坐标字典['黄冈市']
        else:
            return GPS坐标类()

    @property
    def 广元市(self) -> GPS坐标类:
        if '广元市' in _常用坐标字典:
            return _常用坐标字典['广元市']
        else:
            return GPS坐标类()

    @property
    def 巴中市(self) -> GPS坐标类:
        if '巴中市' in _常用坐标字典:
            return _常用坐标字典['巴中市']
        else:
            return GPS坐标类()

    @property
    def 达州市(self) -> GPS坐标类:
        if '达州市' in _常用坐标字典:
            return _常用坐标字典['达州市']
        else:
            return GPS坐标类()

    @property
    def 广安市(self) -> GPS坐标类:
        if '广安市' in _常用坐标字典:
            return _常用坐标字典['广安市']
        else:
            return GPS坐标类()

    @property
    def 南充市(self) -> GPS坐标类:
        if '南充市' in _常用坐标字典:
            return _常用坐标字典['南充市']
        else:
            return GPS坐标类()

    @property
    def 绵阳市(self) -> GPS坐标类:
        if '绵阳市' in _常用坐标字典:
            return _常用坐标字典['绵阳市']
        else:
            return GPS坐标类()

    @property
    def 德阳市(self) -> GPS坐标类:
        if '德阳市' in _常用坐标字典:
            return _常用坐标字典['德阳市']
        else:
            return GPS坐标类()

    @property
    def 遂宁市(self) -> GPS坐标类:
        if '遂宁市' in _常用坐标字典:
            return _常用坐标字典['遂宁市']
        else:
            return GPS坐标类()

    @property
    def 资阳市(self) -> GPS坐标类:
        if '资阳市' in _常用坐标字典:
            return _常用坐标字典['资阳市']
        else:
            return GPS坐标类()

    @property
    def 内江市(self) -> GPS坐标类:
        if '内江市' in _常用坐标字典:
            return _常用坐标字典['内江市']
        else:
            return GPS坐标类()

    @property
    def 泸州市(self) -> GPS坐标类:
        if '泸州市' in _常用坐标字典:
            return _常用坐标字典['泸州市']
        else:
            return GPS坐标类()

    @property
    def 宜宾市(self) -> GPS坐标类:
        if '宜宾市' in _常用坐标字典:
            return _常用坐标字典['宜宾市']
        else:
            return GPS坐标类()

    @property
    def 自贡市(self) -> GPS坐标类:
        if '自贡市' in _常用坐标字典:
            return _常用坐标字典['自贡市']
        else:
            return GPS坐标类()

    @property
    def 乐山市(self) -> GPS坐标类:
        if '乐山市' in _常用坐标字典:
            return _常用坐标字典['乐山市']
        else:
            return GPS坐标类()

    @property
    def 眉山市(self) -> GPS坐标类:
        if '眉山市' in _常用坐标字典:
            return _常用坐标字典['眉山市']
        else:
            return GPS坐标类()

    @property
    def 雅安市(self) -> GPS坐标类:
        if '雅安市' in _常用坐标字典:
            return _常用坐标字典['雅安市']
        else:
            return GPS坐标类()

    @property
    def 攀枝花市(self) -> GPS坐标类:
        if '攀枝花市' in _常用坐标字典:
            return _常用坐标字典['攀枝花市']
        else:
            return GPS坐标类()

    @property
    def 阿贝藏族羌族自治州(self) -> GPS坐标类:
        if '阿贝藏族羌族自治州' in _常用坐标字典:
            return _常用坐标字典['阿贝藏族羌族自治州']
        else:
            return GPS坐标类()

    @property
    def 甘孜藏族自治州(self) -> GPS坐标类:
        if '甘孜藏族自治州' in _常用坐标字典:
            return _常用坐标字典['甘孜藏族自治州']
        else:
            return GPS坐标类()

    @property
    def 凉山彝族自治州(self) -> GPS坐标类:
        if '凉山彝族自治州' in _常用坐标字典:
            return _常用坐标字典['凉山彝族自治州']
        else:
            return GPS坐标类()

    @property
    def 昭通市(self) -> GPS坐标类:
        if '昭通市' in _常用坐标字典:
            return _常用坐标字典['昭通市']
        else:
            return GPS坐标类()

    @property
    def 曲靖市(self) -> GPS坐标类:
        if '曲靖市' in _常用坐标字典:
            return _常用坐标字典['曲靖市']
        else:
            return GPS坐标类()

    @property
    def 丽江市(self) -> GPS坐标类:
        if '丽江市' in _常用坐标字典:
            return _常用坐标字典['丽江市']
        else:
            return GPS坐标类()

    @property
    def 保山市(self) -> GPS坐标类:
        if '保山市' in _常用坐标字典:
            return _常用坐标字典['保山市']
        else:
            return GPS坐标类()

    @property
    def 临沧市(self) -> GPS坐标类:
        if '临沧市' in _常用坐标字典:
            return _常用坐标字典['临沧市']
        else:
            return GPS坐标类()

    @property
    def 玉溪市(self) -> GPS坐标类:
        if '玉溪市' in _常用坐标字典:
            return _常用坐标字典['玉溪市']
        else:
            return GPS坐标类()

    @property
    def 普洱市(self) -> GPS坐标类:
        if '普洱市' in _常用坐标字典:
            return _常用坐标字典['普洱市']
        else:
            return GPS坐标类()

    @property
    def 迪庆藏族自治州(self) -> GPS坐标类:
        if '迪庆藏族自治州' in _常用坐标字典:
            return _常用坐标字典['迪庆藏族自治州']
        else:
            return GPS坐标类()

    @property
    def 大理白族自治州(self) -> GPS坐标类:
        if '大理白族自治州' in _常用坐标字典:
            return _常用坐标字典['大理白族自治州']
        else:
            return GPS坐标类()

    @property
    def 楚雄彝族自治州(self) -> GPS坐标类:
        if '楚雄彝族自治州' in _常用坐标字典:
            return _常用坐标字典['楚雄彝族自治州']
        else:
            return GPS坐标类()

    @property
    def 怒江傈傈族自治州(self) -> GPS坐标类:
        if '怒江傈傈族自治州' in _常用坐标字典:
            return _常用坐标字典['怒江傈傈族自治州']
        else:
            return GPS坐标类()

    @property
    def 德宏傣族景颇族自治州(self) -> GPS坐标类:
        if '德宏傣族景颇族自治州' in _常用坐标字典:
            return _常用坐标字典['德宏傣族景颇族自治州']
        else:
            return GPS坐标类()

    @property
    def 红河哈尼族彝族自治州(self) -> GPS坐标类:
        if '红河哈尼族彝族自治州' in _常用坐标字典:
            return _常用坐标字典['红河哈尼族彝族自治州']
        else:
            return GPS坐标类()

    @property
    def 文山壮族苗族自治州(self) -> GPS坐标类:
        if '文山壮族苗族自治州' in _常用坐标字典:
            return _常用坐标字典['文山壮族苗族自治州']
        else:
            return GPS坐标类()

    @property
    def 西双版纳傣族自治州(self) -> GPS坐标类:
        if '西双版纳傣族自治州' in _常用坐标字典:
            return _常用坐标字典['西双版纳傣族自治州']
        else:
            return GPS坐标类()

    @property
    def 遵义市(self) -> GPS坐标类:
        if '遵义市' in _常用坐标字典:
            return _常用坐标字典['遵义市']
        else:
            return GPS坐标类()

    @property
    def 毕节市(self) -> GPS坐标类:
        if '毕节市' in _常用坐标字典:
            return _常用坐标字典['毕节市']
        else:
            return GPS坐标类()

    @property
    def 六盘水市(self) -> GPS坐标类:
        if '六盘水市' in _常用坐标字典:
            return _常用坐标字典['六盘水市']
        else:
            return GPS坐标类()

    @property
    def 铜仁市(self) -> GPS坐标类:
        if '铜仁市' in _常用坐标字典:
            return _常用坐标字典['铜仁市']
        else:
            return GPS坐标类()

    @property
    def 安顺市(self) -> GPS坐标类:
        if '安顺市' in _常用坐标字典:
            return _常用坐标字典['安顺市']
        else:
            return GPS坐标类()

    @property
    def 黔东南苗族侗族自治州(self) -> GPS坐标类:
        if '黔东南苗族侗族自治州' in _常用坐标字典:
            return _常用坐标字典['黔东南苗族侗族自治州']
        else:
            return GPS坐标类()

    @property
    def 黔南布依族苗族自治州(self) -> GPS坐标类:
        if '黔南布依族苗族自治州' in _常用坐标字典:
            return _常用坐标字典['黔南布依族苗族自治州']
        else:
            return GPS坐标类()

    @property
    def 岳阳市(self) -> GPS坐标类:
        if '岳阳市' in _常用坐标字典:
            return _常用坐标字典['岳阳市']
        else:
            return GPS坐标类()

    @property
    def 张家界市(self) -> GPS坐标类:
        if '张家界市' in _常用坐标字典:
            return _常用坐标字典['张家界市']
        else:
            return GPS坐标类()

    @property
    def 常德市(self) -> GPS坐标类:
        if '常德市' in _常用坐标字典:
            return _常用坐标字典['常德市']
        else:
            return GPS坐标类()

    @property
    def 益阳市(self) -> GPS坐标类:
        if '益阳市' in _常用坐标字典:
            return _常用坐标字典['益阳市']
        else:
            return GPS坐标类()

    @property
    def 湘潭市(self) -> GPS坐标类:
        if '湘潭市' in _常用坐标字典:
            return _常用坐标字典['湘潭市']
        else:
            return GPS坐标类()

    @property
    def 株州市(self) -> GPS坐标类:
        if '株州市' in _常用坐标字典:
            return _常用坐标字典['株州市']
        else:
            return GPS坐标类()

    @property
    def 娄底市(self) -> GPS坐标类:
        if '娄底市' in _常用坐标字典:
            return _常用坐标字典['娄底市']
        else:
            return GPS坐标类()

    @property
    def 邵阳市(self) -> GPS坐标类:
        if '邵阳市' in _常用坐标字典:
            return _常用坐标字典['邵阳市']
        else:
            return GPS坐标类()

    @property
    def 衡阳市(self) -> GPS坐标类:
        if '衡阳市' in _常用坐标字典:
            return _常用坐标字典['衡阳市']
        else:
            return GPS坐标类()

    @property
    def 怀化市(self) -> GPS坐标类:
        if '怀化市' in _常用坐标字典:
            return _常用坐标字典['怀化市']
        else:
            return GPS坐标类()

    @property
    def 永州市(self) -> GPS坐标类:
        if '永州市' in _常用坐标字典:
            return _常用坐标字典['永州市']
        else:
            return GPS坐标类()

    @property
    def 郴州市(self) -> GPS坐标类:
        if '郴州市' in _常用坐标字典:
            return _常用坐标字典['郴州市']
        else:
            return GPS坐标类()

    @property
    def 湘西土家族苗族自治州(self) -> GPS坐标类:
        if '湘西土家族苗族自治州' in _常用坐标字典:
            return _常用坐标字典['湘西土家族苗族自治州']
        else:
            return GPS坐标类()

    @property
    def 九江市(self) -> GPS坐标类:
        if '九江市' in _常用坐标字典:
            return _常用坐标字典['九江市']
        else:
            return GPS坐标类()

    @property
    def 景德镇市(self) -> GPS坐标类:
        if '景德镇市' in _常用坐标字典:
            return _常用坐标字典['景德镇市']
        else:
            return GPS坐标类()

    @property
    def 上饶市(self) -> GPS坐标类:
        if '上饶市' in _常用坐标字典:
            return _常用坐标字典['上饶市']
        else:
            return GPS坐标类()

    @property
    def 鹰潭市(self) -> GPS坐标类:
        if '鹰潭市' in _常用坐标字典:
            return _常用坐标字典['鹰潭市']
        else:
            return GPS坐标类()

    @property
    def 抚州市(self) -> GPS坐标类:
        if '抚州市' in _常用坐标字典:
            return _常用坐标字典['抚州市']
        else:
            return GPS坐标类()

    @property
    def 新余市(self) -> GPS坐标类:
        if '新余市' in _常用坐标字典:
            return _常用坐标字典['新余市']
        else:
            return GPS坐标类()

    @property
    def 宜春市(self) -> GPS坐标类:
        if '宜春市' in _常用坐标字典:
            return _常用坐标字典['宜春市']
        else:
            return GPS坐标类()

    @property
    def 萍乡市(self) -> GPS坐标类:
        if '萍乡市' in _常用坐标字典:
            return _常用坐标字典['萍乡市']
        else:
            return GPS坐标类()

    @property
    def 吉安市(self) -> GPS坐标类:
        if '吉安市' in _常用坐标字典:
            return _常用坐标字典['吉安市']
        else:
            return GPS坐标类()

    @property
    def 赣州市(self) -> GPS坐标类:
        if '赣州市' in _常用坐标字典:
            return _常用坐标字典['赣州市']
        else:
            return GPS坐标类()

    @property
    def 湖州市(self) -> GPS坐标类:
        if '湖州市' in _常用坐标字典:
            return _常用坐标字典['湖州市']
        else:
            return GPS坐标类()

    @property
    def 嘉兴市(self) -> GPS坐标类:
        if '嘉兴市' in _常用坐标字典:
            return _常用坐标字典['嘉兴市']
        else:
            return GPS坐标类()

    @property
    def 绍兴市(self) -> GPS坐标类:
        if '绍兴市' in _常用坐标字典:
            return _常用坐标字典['绍兴市']
        else:
            return GPS坐标类()

    @property
    def 舟山市(self) -> GPS坐标类:
        if '舟山市' in _常用坐标字典:
            return _常用坐标字典['舟山市']
        else:
            return GPS坐标类()

    @property
    def 宁波市(self) -> GPS坐标类:
        if '宁波市' in _常用坐标字典:
            return _常用坐标字典['宁波市']
        else:
            return GPS坐标类()

    @property
    def 金华市(self) -> GPS坐标类:
        if '金华市' in _常用坐标字典:
            return _常用坐标字典['金华市']
        else:
            return GPS坐标类()

    @property
    def 衢州市(self) -> GPS坐标类:
        if '衢州市' in _常用坐标字典:
            return _常用坐标字典['衢州市']
        else:
            return GPS坐标类()

    @property
    def 丽水市(self) -> GPS坐标类:
        if '丽水市' in _常用坐标字典:
            return _常用坐标字典['丽水市']
        else:
            return GPS坐标类()

    @property
    def 台州市(self) -> GPS坐标类:
        if '台州市' in _常用坐标字典:
            return _常用坐标字典['台州市']
        else:
            return GPS坐标类()

    @property
    def 温州市(self) -> GPS坐标类:
        if '温州市' in _常用坐标字典:
            return _常用坐标字典['温州市']
        else:
            return GPS坐标类()

    @property
    def 桂林市(self) -> GPS坐标类:
        if '桂林市' in _常用坐标字典:
            return _常用坐标字典['桂林市']
        else:
            return GPS坐标类()

    @property
    def 贺州市(self) -> GPS坐标类:
        if '贺州市' in _常用坐标字典:
            return _常用坐标字典['贺州市']
        else:
            return GPS坐标类()

    @property
    def 河池市(self) -> GPS坐标类:
        if '河池市' in _常用坐标字典:
            return _常用坐标字典['河池市']
        else:
            return GPS坐标类()

    @property
    def 柳州市(self) -> GPS坐标类:
        if '柳州市' in _常用坐标字典:
            return _常用坐标字典['柳州市']
        else:
            return GPS坐标类()

    @property
    def 梧州市(self) -> GPS坐标类:
        if '梧州市' in _常用坐标字典:
            return _常用坐标字典['梧州市']
        else:
            return GPS坐标类()

    @property
    def 来宾市(self) -> GPS坐标类:
        if '来宾市' in _常用坐标字典:
            return _常用坐标字典['来宾市']
        else:
            return GPS坐标类()

    @property
    def 贵港市(self) -> GPS坐标类:
        if '贵港市' in _常用坐标字典:
            return _常用坐标字典['贵港市']
        else:
            return GPS坐标类()

    @property
    def 玉林市(self) -> GPS坐标类:
        if '玉林市' in _常用坐标字典:
            return _常用坐标字典['玉林市']
        else:
            return GPS坐标类()

    @property
    def 崇左市(self) -> GPS坐标类:
        if '崇左市' in _常用坐标字典:
            return _常用坐标字典['崇左市']
        else:
            return GPS坐标类()

    @property
    def 防城巷市(self) -> GPS坐标类:
        if '防城巷市' in _常用坐标字典:
            return _常用坐标字典['防城巷市']
        else:
            return GPS坐标类()

    @property
    def 钦州市(self) -> GPS坐标类:
        if '钦州市' in _常用坐标字典:
            return _常用坐标字典['钦州市']
        else:
            return GPS坐标类()

    @property
    def 北海市(self) -> GPS坐标类:
        if '北海市' in _常用坐标字典:
            return _常用坐标字典['北海市']
        else:
            return GPS坐标类()

    @property
    def 百色市(self) -> GPS坐标类:
        if '百色市' in _常用坐标字典:
            return _常用坐标字典['百色市']
        else:
            return GPS坐标类()

    @property
    def 韶关市(self) -> GPS坐标类:
        if '韶关市' in _常用坐标字典:
            return _常用坐标字典['韶关市']
        else:
            return GPS坐标类()

    @property
    def 梅州市(self) -> GPS坐标类:
        if '梅州市' in _常用坐标字典:
            return _常用坐标字典['梅州市']
        else:
            return GPS坐标类()

    @property
    def 河源市(self) -> GPS坐标类:
        if '河源市' in _常用坐标字典:
            return _常用坐标字典['河源市']
        else:
            return GPS坐标类()

    @property
    def 清远市(self) -> GPS坐标类:
        if '清远市' in _常用坐标字典:
            return _常用坐标字典['清远市']
        else:
            return GPS坐标类()

    @property
    def 肇庆市(self) -> GPS坐标类:
        if '肇庆市' in _常用坐标字典:
            return _常用坐标字典['肇庆市']
        else:
            return GPS坐标类()

    @property
    def 佛山市(self) -> GPS坐标类:
        if '佛山市' in _常用坐标字典:
            return _常用坐标字典['佛山市']
        else:
            return GPS坐标类()

    @property
    def 中山市(self) -> GPS坐标类:
        if '中山市' in _常用坐标字典:
            return _常用坐标字典['中山市']
        else:
            return GPS坐标类()

    @property
    def 惠州市(self) -> GPS坐标类:
        if '惠州市' in _常用坐标字典:
            return _常用坐标字典['惠州市']
        else:
            return GPS坐标类()

    @property
    def 珠海市(self) -> GPS坐标类:
        if '珠海市' in _常用坐标字典:
            return _常用坐标字典['珠海市']
        else:
            return GPS坐标类()

    @property
    def 云浮市(self) -> GPS坐标类:
        if '云浮市' in _常用坐标字典:
            return _常用坐标字典['云浮市']
        else:
            return GPS坐标类()

    @property
    def 东莞市(self) -> GPS坐标类:
        if '东莞市' in _常用坐标字典:
            return _常用坐标字典['东莞市']
        else:
            return GPS坐标类()

    @property
    def 潮州市(self) -> GPS坐标类:
        if '潮州市' in _常用坐标字典:
            return _常用坐标字典['潮州市']
        else:
            return GPS坐标类()

    @property
    def 汕头市(self) -> GPS坐标类:
        if '汕头市' in _常用坐标字典:
            return _常用坐标字典['汕头市']
        else:
            return GPS坐标类()

    @property
    def 揭阳市(self) -> GPS坐标类:
        if '揭阳市' in _常用坐标字典:
            return _常用坐标字典['揭阳市']
        else:
            return GPS坐标类()

    @property
    def 汕尾市(self) -> GPS坐标类:
        if '汕尾市' in _常用坐标字典:
            return _常用坐标字典['汕尾市']
        else:
            return GPS坐标类()

    @property
    def 深圳市(self) -> GPS坐标类:
        if '深圳市' in _常用坐标字典:
            return _常用坐标字典['深圳市']
        else:
            return GPS坐标类()

    @property
    def 江门市(self) -> GPS坐标类:
        if '江门市' in _常用坐标字典:
            return _常用坐标字典['江门市']
        else:
            return GPS坐标类()

    @property
    def 阳江市(self) -> GPS坐标类:
        if '阳江市' in _常用坐标字典:
            return _常用坐标字典['阳江市']
        else:
            return GPS坐标类()

    @property
    def 茂名市(self) -> GPS坐标类:
        if '茂名市' in _常用坐标字典:
            return _常用坐标字典['茂名市']
        else:
            return GPS坐标类()

    @property
    def 湛江市(self) -> GPS坐标类:
        if '湛江市' in _常用坐标字典:
            return _常用坐标字典['湛江市']
        else:
            return GPS坐标类()

    @property
    def 南平市(self) -> GPS坐标类:
        if '南平市' in _常用坐标字典:
            return _常用坐标字典['南平市']
        else:
            return GPS坐标类()

    @property
    def 宁德市(self) -> GPS坐标类:
        if '宁德市' in _常用坐标字典:
            return _常用坐标字典['宁德市']
        else:
            return GPS坐标类()

    @property
    def 三明市(self) -> GPS坐标类:
        if '三明市' in _常用坐标字典:
            return _常用坐标字典['三明市']
        else:
            return GPS坐标类()

    @property
    def 莆田市(self) -> GPS坐标类:
        if '莆田市' in _常用坐标字典:
            return _常用坐标字典['莆田市']
        else:
            return GPS坐标类()

    @property
    def 泉州市(self) -> GPS坐标类:
        if '泉州市' in _常用坐标字典:
            return _常用坐标字典['泉州市']
        else:
            return GPS坐标类()

    @property
    def 龙岩市(self) -> GPS坐标类:
        if '龙岩市' in _常用坐标字典:
            return _常用坐标字典['龙岩市']
        else:
            return GPS坐标类()

    @property
    def 厦门市(self) -> GPS坐标类:
        if '厦门市' in _常用坐标字典:
            return _常用坐标字典['厦门市']
        else:
            return GPS坐标类()

    @property
    def 漳州市(self) -> GPS坐标类:
        if '漳州市' in _常用坐标字典:
            return _常用坐标字典['漳州市']
        else:
            return GPS坐标类()

    @property
    def 桃园市(self) -> GPS坐标类:
        if '桃园市' in _常用坐标字典:
            return _常用坐标字典['桃园市']
        else:
            return GPS坐标类()

    @property
    def 新北市(self) -> GPS坐标类:
        if '新北市' in _常用坐标字典:
            return _常用坐标字典['新北市']
        else:
            return GPS坐标类()

    @property
    def 台中市(self) -> GPS坐标类:
        if '台中市' in _常用坐标字典:
            return _常用坐标字典['台中市']
        else:
            return GPS坐标类()

    @property
    def 台南市(self) -> GPS坐标类:
        if '台南市' in _常用坐标字典:
            return _常用坐标字典['台南市']
        else:
            return GPS坐标类()

    @property
    def 高雄市(self) -> GPS坐标类:
        if '高雄市' in _常用坐标字典:
            return _常用坐标字典['高雄市']
        else:
            return GPS坐标类()

    @property
    def 儋州市(self) -> GPS坐标类:
        if '儋州市' in _常用坐标字典:
            return _常用坐标字典['儋州市']
        else:
            return GPS坐标类()

    @property
    def 三亚市(self) -> GPS坐标类:
        if '三亚市' in _常用坐标字典:
            return _常用坐标字典['三亚市']
        else:
            return GPS坐标类()

    @property
    def 巴音郭楞蒙古自治州(self) -> GPS坐标类:
        if '巴音郭楞蒙古自治州' in _常用坐标字典:
            return _常用坐标字典['巴音郭楞蒙古自治州']
        else:
            return GPS坐标类()

    @property
    def 锡林郭勒盟(self) -> GPS坐标类:
        if '锡林郭勒盟' in _常用坐标字典:
            return _常用坐标字典['锡林郭勒盟']
        else:
            return GPS坐标类()

    @property
    def 临夏回族自治州(self) -> GPS坐标类:
        if '临夏回族自治州' in _常用坐标字典:
            return _常用坐标字典['临夏回族自治州']
        else:
            return GPS坐标类()

    @property
    def 甘南藏族自治州(self) -> GPS坐标类:
        if '甘南藏族自治州' in _常用坐标字典:
            return _常用坐标字典['甘南藏族自治州']
        else:
            return GPS坐标类()

    @property
    def 黄南藏族自治州(self) -> GPS坐标类:
        if '黄南藏族自治州' in _常用坐标字典:
            return _常用坐标字典['黄南藏族自治州']
        else:
            return GPS坐标类()

    @property
    def 海南藏族自治州(self) -> GPS坐标类:
        if '海南藏族自治州' in _常用坐标字典:
            return _常用坐标字典['海南藏族自治州']
        else:
            return GPS坐标类()

    @property
    def 海北藏族自治州(self) -> GPS坐标类:
        if '海北藏族自治州' in _常用坐标字典:
            return _常用坐标字典['海北藏族自治州']
        else:
            return GPS坐标类()

    @property
    def 海西蒙古族藏族自治州(self) -> GPS坐标类:
        if '海西蒙古族藏族自治州' in _常用坐标字典:
            return _常用坐标字典['海西蒙古族藏族自治州']
        else:
            return GPS坐标类()

    @property
    def 果洛藏族自治州(self) -> GPS坐标类:
        if '果洛藏族自治州' in _常用坐标字典:
            return _常用坐标字典['果洛藏族自治州']
        else:
            return GPS坐标类()

    @property
    def 玉树藏族自治州(self) -> GPS坐标类:
        if '玉树藏族自治州' in _常用坐标字典:
            return _常用坐标字典['玉树藏族自治州']
        else:
            return GPS坐标类()

    @property
    def 阿拉善盟(self) -> GPS坐标类:
        if '阿拉善盟' in _常用坐标字典:
            return _常用坐标字典['阿拉善盟']
        else:
            return GPS坐标类()

    @property
    def 日月潭(self) -> GPS坐标类:
        if '日月潭' in _常用坐标字典:
            return _常用坐标字典['日月潭']
        else:
            return GPS坐标类()

    @property
    def 腾冲市(self) -> GPS坐标类:
        if '腾冲市' in _常用坐标字典:
            return _常用坐标字典['腾冲市']
        else:
            return GPS坐标类()

    @property
    def 墨河市(self) -> GPS坐标类:
        if '墨河市' in _常用坐标字典:
            return _常用坐标字典['墨河市']
        else:
            return GPS坐标类()

    @property
    def 黑河市(self) -> GPS坐标类:
        if '黑河市' in _常用坐标字典:
            return _常用坐标字典['黑河市']
        else:
            return GPS坐标类()

    # endregion
    # endregion

    def 查询坐标(self, 关键字: str) -> GPS坐标类:
        if self.有效 and 关键字:
            if 关键字 in _常用坐标字典.keys():
                return _常用坐标字典[关键字]
            else:
                for key in _常用坐标字典.keys():
                    if 关键字 in key or key in 关键字:
                        return _常用坐标字典[key]
        return GPS坐标类()

    @staticmethod
    def 帮助文档(打印方法: callable = None) -> None:
        画板: _打印模板 = _打印模板()

        画板.添加分隔行('=', None if callable(打印方法) else _黄字)
        画板.添加分隔行('常用坐标定义了一个常用的GPS坐标类对象的集合')

        if callable(打印方法):
            画板.添加一行('属性', '说明')
        else:
            画板.添加一行('属性', '说明').修饰行(_青字)
        画板.添加一行('有效:', '常用坐标字典是否存在, 并且存在坐标数据, 有效为True, 无效为False')
        画板.添加一行('无效:', '常用坐标字典是否存在, 并且存在坐标数据, 无效为True, 有效为False')
        画板.添加一行('常用坐标字典:', '返回一个常用GPS坐标类对象的字典, 结构为: {城市: GPS坐标类对象, ...}')
        画板.添加一行('数量:', '常用坐标字典中GPS坐标类对象的数量')
        画板.添加一行('**市:', '返回指定的城市的GPS坐标对象')

        画板.添加分隔行('-', None if callable(打印方法) else _黄字)
        if callable(打印方法):
            画板.添加一行('方法', '说明')
        else:
            画板.添加一行('方法', '说明').修饰行(_青字)
        画板.添加一行('查询坐标:', '根据指定的关键字,在常用GPS坐标字典中查询对应的GPS坐标对象并返回,如果查询不到,返回空的 GPS坐标类 对象')
        画板.添加一行('', '例如: 上海坐标 = 常用坐标.查询坐标("上海")  # 返回上海市的GPS坐标类对象')
        画板.添加一行('', '又如: 上海坐标 = 常用坐标.查询坐标("上X海")  # 返回空的对象,即 GPS坐标类()')

        画板.添加分隔行('=', None if callable(打印方法) else _黄字)

        画板.展示表格(打印方法=打印方法)


# 生成一个常用坐标对象,用于导出使用
常用坐标: _常用坐标类 = _常用坐标类()
# endregion
